1999-04-07 16:42:40 +02:00
|
|
|
|
// Functions for Exception Support for Java.
|
|
|
|
|
|
2002-02-13 01:29:42 +01:00
|
|
|
|
/* Copyright (C) 1998, 1999, 2001, 2002 Free Software Foundation
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
This file is part of libgcj.
|
|
|
|
|
|
|
|
|
|
This software is copyrighted work licensed under the terms of the
|
|
|
|
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
|
|
|
|
details. */
|
|
|
|
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
|
|
|
|
#include <stddef.h>
|
2002-02-11 23:28:58 +01:00
|
|
|
|
#include <stdlib.h>
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
|
|
|
|
#include <java/lang/Class.h>
|
|
|
|
|
#include <java/lang/NullPointerException.h>
|
2003-08-20 19:27:56 +02:00
|
|
|
|
#include <gnu/gcj/RawData.h>
|
1999-09-11 00:03:10 +02:00
|
|
|
|
#include <gcj/cni.h>
|
1999-04-07 16:42:40 +02:00
|
|
|
|
#include <jvm.h>
|
|
|
|
|
|
unwind-dw2-fde-glibc.c (base_from_cb_data, [...]): Use gcc_assert and gcc_unreachable as appropriate.
* unwind-dw2-fde-glibc.c (base_from_cb_data,
_Unwind_IteratePhdrCallback): Use gcc_assert and gcc_unreachable as
appropriate.
* unwind-dw2-fde.c (__deregister_frame_info_bases,
base_from_object, fde_split, end_fde_sort): Likewise.
* unwind-dw2.c (_Unwind_GetGR, _Unwind_SetGR, execute_stack_op,
execute_cfa_program, _Unwind_SetSpColumn, uw_update_context_1,
uw_init_context_1): Likewise.
* unwind.inc (_Unwind_RaiseException_Phase2, _Unwind_Resume,
_Unwind_Resume_or_Rethrow): Likewise.
* unwind-pe.h (__gxx_abort): Do not define.
(size_of_encoded_value, base_of_encoded_value,
read_encoded_value_with_base): Use gcc_unreachable.
* unwind.h (_Unwind_GetTextRelBase): Likewise.
From-SVN: r99835
2005-05-17 17:37:47 +02:00
|
|
|
|
// Sometimes we compile libjava without libstdc++-v3. Therefore make
|
|
|
|
|
// sure we use stdlib.h's abort().
|
|
|
|
|
#define gcc_unreachable() ::abort ()
|
2001-03-28 13:04:51 +02:00
|
|
|
|
#include "unwind.h"
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
struct alignment_test_struct
|
|
|
|
|
{
|
|
|
|
|
char space;
|
|
|
|
|
char end[0] __attribute__((aligned));
|
|
|
|
|
};
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
struct java_exception_header
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
/* Cache handler details between Phase 1 and Phase 2. */
|
|
|
|
|
_Unwind_Ptr landingPad;
|
|
|
|
|
int handlerSwitchValue;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
/* The object being thrown. Compiled code expects this to be immediately
|
|
|
|
|
before the generic exception header. Which is complicated by the fact
|
|
|
|
|
that _Unwind_Exception is ((aligned)). */
|
|
|
|
|
|
|
|
|
|
char pad[sizeof(jthrowable) < sizeof(alignment_test_struct)
|
|
|
|
|
? sizeof(alignment_test_struct) - sizeof(jthrowable) : 0]
|
|
|
|
|
__attribute__((aligned));
|
|
|
|
|
|
|
|
|
|
jthrowable value;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
/* The generic exception header. */
|
|
|
|
|
_Unwind_Exception unwindHeader;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// This is the exception class we report -- "GNUCJAVA".
|
|
|
|
|
const _Unwind_Exception_Class __gcj_exception_class
|
|
|
|
|
= ((((((((_Unwind_Exception_Class) 'G'
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'N')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'U')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'C')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'J')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'A')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'V')
|
|
|
|
|
<< 8 | (_Unwind_Exception_Class) 'A');
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static inline java_exception_header *
|
|
|
|
|
get_exception_header_from_ue (_Unwind_Exception *exc)
|
|
|
|
|
{
|
|
|
|
|
return reinterpret_cast<java_exception_header *>(exc + 1) - 1;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
/* Perform a throw, Java style. Throw will unwind through this call,
|
|
|
|
|
so there better not be any handlers or exception thrown here. */
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
extern "C" void
|
|
|
|
|
_Jv_Throw (jthrowable value)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
java_exception_header *xh
|
2001-09-10 03:21:08 +02:00
|
|
|
|
= static_cast<java_exception_header *>(_Jv_AllocRawObj (sizeof (*xh)));
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
if (value == NULL)
|
|
|
|
|
value = new java::lang::NullPointerException ();
|
|
|
|
|
xh->value = value;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
xh->unwindHeader.exception_class = __gcj_exception_class;
|
|
|
|
|
xh->unwindHeader.exception_cleanup = NULL;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
/* We're happy with setjmp/longjmp exceptions or region-based
|
|
|
|
|
exception handlers: entry points are provided here for both. */
|
|
|
|
|
_Unwind_Reason_Code code;
|
|
|
|
|
#ifdef SJLJ_EXCEPTIONS
|
|
|
|
|
code = _Unwind_SjLj_RaiseException (&xh->unwindHeader);
|
|
|
|
|
#else
|
|
|
|
|
code = _Unwind_RaiseException (&xh->unwindHeader);
|
|
|
|
|
#endif
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-04-03 01:26:50 +02:00
|
|
|
|
/* If code == _URC_END_OF_STACK, then we reached top of stack without
|
|
|
|
|
finding a handler for the exception. Since each thread is run in
|
|
|
|
|
a try/catch, this oughtn't happen. If code is something else, we
|
|
|
|
|
encountered some sort of heinous lossage from which we could not
|
|
|
|
|
recover. As is the way of such things, almost certainly we will have
|
|
|
|
|
crashed before now, rather than actually being able to diagnose the
|
|
|
|
|
problem. */
|
2002-02-11 23:28:58 +01:00
|
|
|
|
abort();
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
2001-05-12 08:17:31 +02:00
|
|
|
|
#include "unwind-pe.h"
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
struct lsda_header_info
|
|
|
|
|
{
|
|
|
|
|
_Unwind_Ptr Start;
|
|
|
|
|
_Unwind_Ptr LPStart;
|
|
|
|
|
const unsigned char *TType;
|
|
|
|
|
const unsigned char *action_table;
|
|
|
|
|
unsigned char ttype_encoding;
|
|
|
|
|
unsigned char call_site_encoding;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const unsigned char *
|
|
|
|
|
parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
|
|
|
|
|
lsda_header_info *info)
|
|
|
|
|
{
|
2001-08-31 14:27:32 +02:00
|
|
|
|
_Unwind_Word tmp;
|
2001-03-28 13:04:51 +02:00
|
|
|
|
unsigned char lpstart_encoding;
|
|
|
|
|
|
|
|
|
|
info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// Find @LPStart, the base to which landing pad offsets are relative.
|
|
|
|
|
lpstart_encoding = *p++;
|
|
|
|
|
if (lpstart_encoding != DW_EH_PE_omit)
|
|
|
|
|
p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
|
|
|
|
|
else
|
|
|
|
|
info->LPStart = info->Start;
|
|
|
|
|
|
|
|
|
|
// Find @TType, the base of the handler and exception spec type data.
|
|
|
|
|
info->ttype_encoding = *p++;
|
|
|
|
|
if (info->ttype_encoding != DW_EH_PE_omit)
|
|
|
|
|
{
|
|
|
|
|
p = read_uleb128 (p, &tmp);
|
|
|
|
|
info->TType = p + tmp;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
info->TType = 0;
|
|
|
|
|
|
|
|
|
|
// The encoding and length of the call-site table; the action table
|
|
|
|
|
// immediately follows.
|
|
|
|
|
info->call_site_encoding = *p++;
|
|
|
|
|
p = read_uleb128 (p, &tmp);
|
|
|
|
|
info->action_table = p + tmp;
|
|
|
|
|
|
|
|
|
|
return p;
|
|
|
|
|
}
|
|
|
|
|
|
2003-10-24 11:29:43 +02:00
|
|
|
|
static void **
|
2001-03-28 13:04:51 +02:00
|
|
|
|
get_ttype_entry (_Unwind_Context *context, lsda_header_info *info, long i)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
_Unwind_Ptr ptr;
|
|
|
|
|
|
|
|
|
|
i *= size_of_encoded_value (info->ttype_encoding);
|
|
|
|
|
read_encoded_value (context, info->ttype_encoding, info->TType - i, &ptr);
|
|
|
|
|
|
2003-10-24 11:29:43 +02:00
|
|
|
|
return reinterpret_cast<void **>(ptr);
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
|
|
|
|
|
1999-11-19 20:13:42 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// Using a different personality function name causes link failures
|
|
|
|
|
// when trying to mix code using different exception handling models.
|
exception.cc (java_eh_info): Make value type jthrowable.
* exception.cc (java_eh_info): Make value type jthrowable.
(_Jv_type_matcher): Remove now unneeded cast.
(_Jv_Throw): Make argument type jthrowable. Munge name
for SJLJ_EXCEPTIONS here ...
* gcj/cni.h: ... not here.
(JvThrow): Remove.
* gcj/javaprims.h (_Jv_Throw, _Jv_Sjlj_Throw): Update declarations.
* defineclass.cc, interpret.cc, jni.cc, posix-threads.cc,
prims.cc, resolve.cc, gnu/gcj/runtime/natFirstThread.cc,
gnu/gcj/xlib/natDrawable.cc, gnu/gcj/xlib/natFont.cc,
gnu/gcj/xlib/natWMSizeHints.cc, gnu/gcj/xlib/natWindowAttributes.cc,
gnu/gcj/xlib/natXImage.cc, java/io/natFile.cc,
java/io/natFileDescriptorEcos.cc, java/io/natFileDescriptorPosix.cc,
java/io/natFileDescriptorWin32.cc, java/io/natFileWin32.cc,
java/lang/natClass.cc, java/lang/natClassLoader.cc,
java/lang/natDouble.cc, java/lang/natObject.cc,
java/lang/natPosixProcess.cc, java/lang/natRuntime.cc,
java/lang/natString.cc, java/lang/natSystem.cc,
java/lang/natThread.cc, java/lang/reflect/natArray.cc,
java/lang/reflect/natConstructor.cc, java/lang/reflect/natField.cc,
java/lang/reflect/natMethod.cc, java/util/zip/natDeflater.cc,
java/util/zip/natInflater.cc:
Use throw, not JvThrow or _Jv_Throw.
From-SVN: r40838
2001-03-26 09:05:32 +02:00
|
|
|
|
#ifdef SJLJ_EXCEPTIONS
|
2001-03-28 13:04:51 +02:00
|
|
|
|
#define PERSONALITY_FUNCTION __gcj_personality_sj0
|
|
|
|
|
#define __builtin_eh_return_data_regno(x) x
|
|
|
|
|
#else
|
|
|
|
|
#define PERSONALITY_FUNCTION __gcj_personality_v0
|
exception.cc (java_eh_info): Make value type jthrowable.
* exception.cc (java_eh_info): Make value type jthrowable.
(_Jv_type_matcher): Remove now unneeded cast.
(_Jv_Throw): Make argument type jthrowable. Munge name
for SJLJ_EXCEPTIONS here ...
* gcj/cni.h: ... not here.
(JvThrow): Remove.
* gcj/javaprims.h (_Jv_Throw, _Jv_Sjlj_Throw): Update declarations.
* defineclass.cc, interpret.cc, jni.cc, posix-threads.cc,
prims.cc, resolve.cc, gnu/gcj/runtime/natFirstThread.cc,
gnu/gcj/xlib/natDrawable.cc, gnu/gcj/xlib/natFont.cc,
gnu/gcj/xlib/natWMSizeHints.cc, gnu/gcj/xlib/natWindowAttributes.cc,
gnu/gcj/xlib/natXImage.cc, java/io/natFile.cc,
java/io/natFileDescriptorEcos.cc, java/io/natFileDescriptorPosix.cc,
java/io/natFileDescriptorWin32.cc, java/io/natFileWin32.cc,
java/lang/natClass.cc, java/lang/natClassLoader.cc,
java/lang/natDouble.cc, java/lang/natObject.cc,
java/lang/natPosixProcess.cc, java/lang/natRuntime.cc,
java/lang/natString.cc, java/lang/natSystem.cc,
java/lang/natThread.cc, java/lang/reflect/natArray.cc,
java/lang/reflect/natConstructor.cc, java/lang/reflect/natField.cc,
java/lang/reflect/natMethod.cc, java/util/zip/natDeflater.cc,
java/util/zip/natInflater.cc:
Use throw, not JvThrow or _Jv_Throw.
From-SVN: r40838
2001-03-26 09:05:32 +02:00
|
|
|
|
#endif
|
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
extern "C" _Unwind_Reason_Code
|
|
|
|
|
PERSONALITY_FUNCTION (int version,
|
|
|
|
|
_Unwind_Action actions,
|
|
|
|
|
_Unwind_Exception_Class exception_class,
|
|
|
|
|
struct _Unwind_Exception *ue_header,
|
|
|
|
|
struct _Unwind_Context *context)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
java_exception_header *xh = get_exception_header_from_ue (ue_header);
|
|
|
|
|
|
|
|
|
|
lsda_header_info info;
|
|
|
|
|
const unsigned char *language_specific_data;
|
|
|
|
|
const unsigned char *action_record;
|
|
|
|
|
const unsigned char *p;
|
|
|
|
|
_Unwind_Ptr landing_pad, ip;
|
|
|
|
|
int handler_switch_value;
|
|
|
|
|
bool saw_cleanup;
|
|
|
|
|
bool saw_handler;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Interface version check.
|
|
|
|
|
if (version != 1)
|
|
|
|
|
return _URC_FATAL_PHASE1_ERROR;
|
|
|
|
|
|
|
|
|
|
// Shortcut for phase 2 found handler for domestic exception.
|
|
|
|
|
if (actions == (_UA_CLEANUP_PHASE | _UA_HANDLER_FRAME)
|
|
|
|
|
&& exception_class == __gcj_exception_class)
|
1999-04-07 16:42:40 +02:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
handler_switch_value = xh->handlerSwitchValue;
|
|
|
|
|
landing_pad = xh->landingPad;
|
|
|
|
|
goto install_context;
|
1999-04-07 16:42:40 +02:00
|
|
|
|
}
|
1999-11-19 20:13:42 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// FIXME: In Phase 1, record _Unwind_GetIP in xh->obj as a part of
|
|
|
|
|
// the stack trace for this exception. This will only collect Java
|
|
|
|
|
// frames, but perhaps that is acceptable.
|
|
|
|
|
// FIXME2: _Unwind_GetIP is nonsensical for SJLJ, being a call-site
|
|
|
|
|
// index instead of a PC value. We could perhaps arrange for
|
|
|
|
|
// _Unwind_GetRegionStart to return context->fc->jbuf[1], which
|
|
|
|
|
// is the address of the handler label for __builtin_longjmp, but
|
|
|
|
|
// there is no solution for DONT_USE_BUILTIN_SETJMP.
|
|
|
|
|
|
|
|
|
|
language_specific_data = (const unsigned char *)
|
|
|
|
|
_Unwind_GetLanguageSpecificData (context);
|
|
|
|
|
|
|
|
|
|
// If no LSDA, then there are no handlers or cleanups.
|
|
|
|
|
if (! language_specific_data)
|
|
|
|
|
return _URC_CONTINUE_UNWIND;
|
|
|
|
|
|
|
|
|
|
// Parse the LSDA header.
|
|
|
|
|
p = parse_lsda_header (context, language_specific_data, &info);
|
|
|
|
|
ip = _Unwind_GetIP (context) - 1;
|
|
|
|
|
landing_pad = 0;
|
|
|
|
|
action_record = 0;
|
|
|
|
|
handler_switch_value = 0;
|
|
|
|
|
|
1999-11-19 20:13:42 +01:00
|
|
|
|
#ifdef SJLJ_EXCEPTIONS
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// The given "IP" is an index into the call-site table, with two
|
|
|
|
|
// exceptions -- -1 means no-action, and 0 means terminate. But
|
|
|
|
|
// since we're using uleb128 values, we've not got random access
|
|
|
|
|
// to the array.
|
|
|
|
|
if ((int) ip <= 0)
|
|
|
|
|
return _URC_CONTINUE_UNWIND;
|
|
|
|
|
else
|
|
|
|
|
{
|
2001-08-31 14:27:32 +02:00
|
|
|
|
_Unwind_Word cs_lp, cs_action;
|
2001-03-28 13:04:51 +02:00
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
p = read_uleb128 (p, &cs_lp);
|
|
|
|
|
p = read_uleb128 (p, &cs_action);
|
|
|
|
|
}
|
|
|
|
|
while (--ip);
|
|
|
|
|
|
|
|
|
|
// Can never have null landing pad for sjlj -- that would have
|
|
|
|
|
// been indicated by a -1 call site index.
|
|
|
|
|
landing_pad = cs_lp + 1;
|
|
|
|
|
if (cs_action)
|
|
|
|
|
action_record = info.action_table + cs_action - 1;
|
|
|
|
|
goto found_something;
|
|
|
|
|
}
|
1999-11-19 20:13:42 +01:00
|
|
|
|
#else
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// Search the call-site table for the action associated with this IP.
|
|
|
|
|
while (p < info.action_table)
|
|
|
|
|
{
|
2001-08-31 14:27:32 +02:00
|
|
|
|
_Unwind_Ptr cs_start, cs_len, cs_lp;
|
|
|
|
|
_Unwind_Word cs_action;
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
// Note that all call-site encodings are "absolute" displacements.
|
|
|
|
|
p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
|
|
|
|
|
p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
|
|
|
|
|
p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
|
|
|
|
|
p = read_uleb128 (p, &cs_action);
|
|
|
|
|
|
|
|
|
|
// The table is sorted, so if we've passed the ip, stop.
|
|
|
|
|
if (ip < info.Start + cs_start)
|
|
|
|
|
p = info.action_table;
|
|
|
|
|
else if (ip < info.Start + cs_start + cs_len)
|
|
|
|
|
{
|
|
|
|
|
if (cs_lp)
|
|
|
|
|
landing_pad = info.LPStart + cs_lp;
|
|
|
|
|
if (cs_action)
|
|
|
|
|
action_record = info.action_table + cs_action - 1;
|
|
|
|
|
goto found_something;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif // SJLJ_EXCEPTIONS
|
2000-03-15 23:03:19 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// If ip is not present in the table, C++ would call terminate.
|
|
|
|
|
// ??? It is perhaps better to tweek the LSDA so that no-action
|
|
|
|
|
// is mapped to no-entry for Java.
|
|
|
|
|
return _URC_CONTINUE_UNWIND;
|
2000-03-15 23:03:19 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
found_something:
|
|
|
|
|
saw_cleanup = false;
|
|
|
|
|
saw_handler = false;
|
2000-03-15 23:03:19 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
if (landing_pad == 0)
|
2000-03-15 23:03:19 +01:00
|
|
|
|
{
|
2001-03-28 13:04:51 +02:00
|
|
|
|
// If ip is present, and has a null landing pad, there are
|
|
|
|
|
// no cleanups or handlers to be run.
|
|
|
|
|
}
|
|
|
|
|
else if (action_record == 0)
|
|
|
|
|
{
|
|
|
|
|
// If ip is present, has a non-null landing pad, and a null
|
|
|
|
|
// action table offset, then there are only cleanups present.
|
|
|
|
|
// Cleanups use a zero switch value, as set above.
|
|
|
|
|
saw_cleanup = true;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// Otherwise we have a catch handler.
|
2001-08-31 14:27:32 +02:00
|
|
|
|
_Unwind_Sword ar_filter, ar_disp;
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
p = action_record;
|
2001-08-31 14:27:32 +02:00
|
|
|
|
p = read_sleb128 (p, &ar_filter);
|
|
|
|
|
read_sleb128 (p, &ar_disp);
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
if (ar_filter == 0)
|
|
|
|
|
{
|
|
|
|
|
// Zero filter values are cleanups.
|
|
|
|
|
saw_cleanup = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// During forced unwinding, we only run cleanups. With a
|
|
|
|
|
// foreign exception class, we have no class info to match.
|
|
|
|
|
else if ((actions & _UA_FORCE_UNWIND)
|
|
|
|
|
|| exception_class != __gcj_exception_class)
|
|
|
|
|
;
|
|
|
|
|
|
|
|
|
|
else if (ar_filter > 0)
|
|
|
|
|
{
|
|
|
|
|
// Positive filter values are handlers.
|
|
|
|
|
|
2003-10-24 11:29:43 +02:00
|
|
|
|
void **catch_word = get_ttype_entry (context, &info, ar_filter);
|
|
|
|
|
jclass catch_type = (jclass)*catch_word;
|
|
|
|
|
|
|
|
|
|
// FIXME: This line is a kludge to work around exception
|
|
|
|
|
// handlers written in C++, which don't yet use indirect
|
|
|
|
|
// dispatch.
|
|
|
|
|
if (catch_type == *(void **)&java::lang::Class::class$)
|
|
|
|
|
catch_type = (jclass)catch_word;
|
2001-03-28 13:04:51 +02:00
|
|
|
|
|
|
|
|
|
if (_Jv_IsInstanceOf (xh->value, catch_type))
|
|
|
|
|
{
|
|
|
|
|
handler_switch_value = ar_filter;
|
|
|
|
|
saw_handler = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// Negative filter values are exception specifications,
|
|
|
|
|
// which Java does not use.
|
|
|
|
|
// ??? Perhaps better to make them an index into a table
|
|
|
|
|
// of null-terminated strings instead of playing games
|
|
|
|
|
// with Utf8Const+1 as above.
|
2002-02-11 23:28:58 +01:00
|
|
|
|
abort ();
|
2001-03-28 13:04:51 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ar_disp == 0)
|
|
|
|
|
break;
|
|
|
|
|
action_record = p + ar_disp;
|
|
|
|
|
}
|
2000-03-15 23:03:19 +01:00
|
|
|
|
}
|
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
if (! saw_handler && ! saw_cleanup)
|
|
|
|
|
return _URC_CONTINUE_UNWIND;
|
2000-03-15 23:03:19 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
if (actions & _UA_SEARCH_PHASE)
|
|
|
|
|
{
|
|
|
|
|
if (! saw_handler)
|
|
|
|
|
return _URC_CONTINUE_UNWIND;
|
|
|
|
|
|
|
|
|
|
// For domestic exceptions, we cache data from phase 1 for phase 2.
|
|
|
|
|
if (exception_class == __gcj_exception_class)
|
|
|
|
|
{
|
|
|
|
|
xh->handlerSwitchValue = handler_switch_value;
|
|
|
|
|
xh->landingPad = landing_pad;
|
|
|
|
|
}
|
|
|
|
|
return _URC_HANDLER_FOUND;
|
|
|
|
|
}
|
2000-03-15 23:03:19 +01:00
|
|
|
|
|
2001-03-28 13:04:51 +02:00
|
|
|
|
install_context:
|
|
|
|
|
_Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
|
|
|
|
|
(_Unwind_Ptr) &xh->unwindHeader);
|
|
|
|
|
_Unwind_SetGR (context, __builtin_eh_return_data_regno (1),
|
|
|
|
|
handler_switch_value);
|
|
|
|
|
_Unwind_SetIP (context, landing_pad);
|
|
|
|
|
return _URC_INSTALL_CONTEXT;
|
2000-03-15 23:03:19 +01:00
|
|
|
|
}
|