mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2024-12-17 18:19:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

unwind-pe.h (read_uleb128, [...]): Move actual reading code here.

Browse Source 
* unwind-pe.h (read_uleb128, read_sleb128): Move actual reading
        code here.  Take _Unwind_{W,Sw}ord*.
        (read_encoded_value_with_base): Use them.
        * unwind-dw2.c (_Unwind_FrameState): Make cfa_offset and cfa_reg
        words.
        (extract_cie_info): Simplify read_?leb128 handling.
        (execute_stack_op, execute_cfa_program): Likewise.
        * unwind-dw2-fde.c (get_cie_encoding): Likewise.

        * libsupc++/eh_personality.cc (PERSONALITY_FUNCTION): Simplify
        leb128 handling.

From-SVN: r45315
This commit is contained in:
Jason Merrill 2001-08-31 05:49:13 -04:00 committed by Jason Merrill
parent e2470e1be7
commit a9985a921e
6 changed files with 137 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
gcc/ChangeLog
View File

@ -1,3 +1,14 @@
2001-08-31 Jason Merrill <jason_merrill@redhat.com>
* unwind-pe.h (read_uleb128, read_sleb128): Move actual reading
code here. Take _Unwind_{W,Sw}ord*.
(read_encoded_value_with_base): Use them.
* unwind-dw2.c (_Unwind_FrameState): Make cfa_offset and cfa_reg
words.
(extract_cie_info): Simplify read_?leb128 handling.
(execute_stack_op, execute_cfa_program): Likewise.
* unwind-dw2-fde.c (get_cie_encoding): Likewise.
2001-08-31 Geoffrey Keating <geoffk@redhat.com> 2001-08-31 Geoffrey Keating <geoffk@redhat.com>
* config/stormy16/stormy16.c (stormy16_expand_epilogue): Use * config/stormy16/stormy16.c (stormy16_expand_epilogue): Use

8
gcc/unwind-dw2-fde.c
View File

@ -243,18 +243,20 @@ get_cie_encoding (struct dwarf_cie *cie)
{ {
const unsigned char *aug, *p; const unsigned char *aug, *p;
_Unwind_Ptr dummy; _Unwind_Ptr dummy;
_Unwind_Word utmp;
_Unwind_Sword stmp;
aug = cie->augmentation; aug = cie->augmentation;
if (aug[0] != 'z') if (aug[0] != 'z')
return DW_EH_PE_absptr; return DW_EH_PE_absptr;
p = aug + strlen (aug) + 1; /* Skip the augmentation string. */ p = aug + strlen (aug) + 1; /* Skip the augmentation string. */
p = read_uleb128 (p, &dummy); /* Skip code alignment. */ p = read_uleb128 (p, &utmp); /* Skip code alignment. */
p = read_sleb128 (p, &dummy); /* Skip data alignment. */ p = read_sleb128 (p, &stmp); /* Skip data alignment. */
p++; /* Skip return address column. */ p++; /* Skip return address column. */
aug++; /* Skip 'z' */ aug++; /* Skip 'z' */
p = read_uleb128 (p, &dummy); /* Skip augmentation length. */ p = read_uleb128 (p, &utmp); /* Skip augmentation length. */
while (1) while (1)
{ {
/* This is what we're looking for. */ /* This is what we're looking for. */

115
gcc/unwind-dw2.c
View File

@ -68,7 +68,7 @@ typedef struct
{ {
struct { struct {
union { union {
unsigned int reg; _Unwind_Word reg;
_Unwind_Sword offset; _Unwind_Sword offset;
const unsigned char *exp; const unsigned char *exp;
} loc; } loc;
@ -100,8 +100,8 @@ typedef struct
/* The information we care about from the CIE/FDE. */ /* The information we care about from the CIE/FDE. */
_Unwind_Personality_Fn personality; _Unwind_Personality_Fn personality;
signed int data_align; _Unwind_Sword data_align;
unsigned int code_align; _Unwind_Word code_align;
unsigned char retaddr_column; unsigned char retaddr_column;
unsigned char fde_encoding; unsigned char fde_encoding;
unsigned char lsda_encoding; unsigned char lsda_encoding;
@ -219,7 +219,7 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
const unsigned char *aug = cie->augmentation; const unsigned char *aug = cie->augmentation;
const unsigned char *p = aug + strlen (aug) + 1; const unsigned char *p = aug + strlen (aug) + 1;
const unsigned char *ret = NULL; const unsigned char *ret = NULL;
_Unwind_Ptr tmp; _Unwind_Word utmp;
/* g++ v2 "eh" has pointer immediately following augmentation string, /* g++ v2 "eh" has pointer immediately following augmentation string,
so it must be handled first. */ so it must be handled first. */
@ -232,8 +232,8 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
/* Immediately following the augmentation are the code and /* Immediately following the augmentation are the code and
data alignment and return address column. */ data alignment and return address column. */
p = read_uleb128 (p, &tmp); fs->code_align = tmp; p = read_uleb128 (p, &fs->code_align);
p = read_sleb128 (p, &tmp); fs->data_align = (saddr) tmp; p = read_sleb128 (p, &fs->data_align);
fs->retaddr_column = *p++; fs->retaddr_column = *p++;
fs->lsda_encoding = DW_EH_PE_omit; fs->lsda_encoding = DW_EH_PE_omit;
@ -242,8 +242,8 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context,
the size. */ the size. */
if (*aug == 'z') if (*aug == 'z')
{ {
p = read_uleb128 (p, &tmp); p = read_uleb128 (p, &utmp);
ret = p + tmp; ret = p + utmp;
fs->saw_z = 1; fs->saw_z = 1;
++aug; ++aug;
@ -300,9 +300,8 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
while (op_ptr < op_end) while (op_ptr < op_end)
{ {
enum dwarf_location_atom op = *op_ptr++; enum dwarf_location_atom op = *op_ptr++;
_Unwind_Word result, reg; _Unwind_Word result, reg, utmp;
_Unwind_Sword offset; _Unwind_Sword offset, stmp;
_Unwind_Ptr ptrtmp;
switch (op) switch (op)
{ {
@ -379,12 +378,11 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
op_ptr += 8; op_ptr += 8;
break; break;
case DW_OP_constu: case DW_OP_constu:
op_ptr = read_uleb128 (op_ptr, &ptrtmp); op_ptr = read_uleb128 (op_ptr, &result);
result = ptrtmp;
break; break;
case DW_OP_consts: case DW_OP_consts:
op_ptr = read_sleb128 (op_ptr, &ptrtmp); op_ptr = read_sleb128 (op_ptr, &stmp);
result = (saddr)ptrtmp; result = stmp;
break; break;
case DW_OP_reg0: case DW_OP_reg0:
@ -422,7 +420,7 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
result = _Unwind_GetGR (context, op - DW_OP_reg0); result = _Unwind_GetGR (context, op - DW_OP_reg0);
break; break;
case DW_OP_regx: case DW_OP_regx:
op_ptr = read_uleb128 (op_ptr, &ptrtmp); reg = ptrtmp; op_ptr = read_uleb128 (op_ptr, &reg);
result = _Unwind_GetGR (context, reg); result = _Unwind_GetGR (context, reg);
break; break;
@ -458,12 +456,12 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
case DW_OP_breg29: case DW_OP_breg29:
case DW_OP_breg30: case DW_OP_breg30:
case DW_OP_breg31: case DW_OP_breg31:
op_ptr = read_sleb128 (op_ptr, &ptrtmp); offset = (saddr)ptrtmp; op_ptr = read_sleb128 (op_ptr, &offset);
result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset; result = _Unwind_GetGR (context, op - DW_OP_breg0) + offset;
break; break;
case DW_OP_bregx: case DW_OP_bregx:
op_ptr = read_uleb128 (op_ptr, &ptrtmp); reg = ptrtmp; op_ptr = read_uleb128 (op_ptr, &reg);
op_ptr = read_sleb128 (op_ptr, &ptrtmp); offset = (saddr)ptrtmp; op_ptr = read_sleb128 (op_ptr, &offset);
result = _Unwind_GetGR (context, reg) + offset; result = _Unwind_GetGR (context, reg) + offset;
break; break;
@ -560,8 +558,8 @@ execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end,
result = ~result; result = ~result;
break; break;
case DW_OP_plus_uconst: case DW_OP_plus_uconst:
op_ptr = read_uleb128 (op_ptr, &ptrtmp); reg = ptrtmp; op_ptr = read_uleb128 (op_ptr, &utmp);
result += reg; result += utmp;
break; break;
default: default:
@ -705,17 +703,16 @@ execute_cfa_program (const unsigned char *insn_ptr,
while (insn_ptr < insn_end && fs->pc < context->ra) while (insn_ptr < insn_end && fs->pc < context->ra)
{ {
unsigned char insn = *insn_ptr++; unsigned char insn = *insn_ptr++;
_Unwind_Word reg; _Unwind_Word reg, utmp;
_Unwind_Sword offset; _Unwind_Sword offset, stmp;
_Unwind_Ptr ptrtmp;
if (insn & DW_CFA_advance_loc) if (insn & DW_CFA_advance_loc)
fs->pc += (insn & 0x3f) * fs->code_align; fs->pc += (insn & 0x3f) * fs->code_align;
else if (insn & DW_CFA_offset) else if (insn & DW_CFA_offset)
{ {
reg = insn & 0x3f; reg = insn & 0x3f;
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
offset = ptrtmp * fs->data_align; offset = (_Unwind_Sword)utmp * fs->data_align;
fs->regs.reg[reg].how = REG_SAVED_OFFSET; fs->regs.reg[reg].how = REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset; fs->regs.reg[reg].loc.offset = offset;
} }
@ -745,15 +742,15 @@ execute_cfa_program (const unsigned char *insn_ptr,
break; break;
case DW_CFA_offset_extended: case DW_CFA_offset_extended:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
offset = ptrtmp * fs->data_align; offset = (_Unwind_Sword)utmp * fs->data_align;
fs->regs.reg[reg].how = REG_SAVED_OFFSET; fs->regs.reg[reg].how = REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset; fs->regs.reg[reg].loc.offset = offset;
break; break;
case DW_CFA_restore_extended: case DW_CFA_restore_extended:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
fs->regs.reg[reg].how = REG_UNSAVED; fs->regs.reg[reg].how = REG_UNSAVED;
break; break;
@ -765,8 +762,8 @@ execute_cfa_program (const unsigned char *insn_ptr,
case DW_CFA_register: case DW_CFA_register:
{ {
_Unwind_Word reg2; _Unwind_Word reg2;
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg2 = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg2);
fs->regs.reg[reg].how = REG_SAVED_REG; fs->regs.reg[reg].how = REG_SAVED_REG;
fs->regs.reg[reg].loc.reg = reg2; fs->regs.reg[reg].loc.reg = reg2;
} }
@ -798,60 +795,55 @@ execute_cfa_program (const unsigned char *insn_ptr,
break; break;
case DW_CFA_def_cfa: case DW_CFA_def_cfa:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
fs->cfa_reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &utmp);
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); fs->cfa_offset = utmp;
fs->cfa_offset = ptrtmp;
fs->cfa_how = CFA_REG_OFFSET; fs->cfa_how = CFA_REG_OFFSET;
break; break;
case DW_CFA_def_cfa_register: case DW_CFA_def_cfa_register:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
fs->cfa_reg = ptrtmp;
fs->cfa_how = CFA_REG_OFFSET; fs->cfa_how = CFA_REG_OFFSET;
break; break;
case DW_CFA_def_cfa_offset: case DW_CFA_def_cfa_offset:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
fs->cfa_offset = ptrtmp; fs->cfa_offset = utmp;
/* cfa_how deliberately not set. */ /* cfa_how deliberately not set. */
break; break;
case DW_CFA_def_cfa_expression: case DW_CFA_def_cfa_expression:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
fs->cfa_exp = insn_ptr; fs->cfa_exp = insn_ptr;
fs->cfa_how = CFA_EXP; fs->cfa_how = CFA_EXP;
insn_ptr += ptrtmp; insn_ptr += utmp;
break; break;
case DW_CFA_expression: case DW_CFA_expression:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
fs->regs.reg[reg].how = REG_SAVED_EXP; fs->regs.reg[reg].how = REG_SAVED_EXP;
fs->regs.reg[reg].loc.exp = insn_ptr; fs->regs.reg[reg].loc.exp = insn_ptr;
insn_ptr += ptrtmp; insn_ptr += utmp;
break; break;
/* From the 2.1 draft. */ /* From the 2.1 draft. */
case DW_CFA_offset_extended_sf: case DW_CFA_offset_extended_sf:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
insn_ptr = read_sleb128 (insn_ptr, &ptrtmp); insn_ptr = read_sleb128 (insn_ptr, &stmp);
offset = (saddr)ptrtmp * fs->data_align; offset = stmp * fs->data_align;
fs->regs.reg[reg].how = REG_SAVED_OFFSET; fs->regs.reg[reg].how = REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = offset; fs->regs.reg[reg].loc.offset = offset;
break; break;
case DW_CFA_def_cfa_sf: case DW_CFA_def_cfa_sf:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &fs->cfa_reg);
fs->cfa_reg = ptrtmp; insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
insn_ptr = read_sleb128 (insn_ptr, &ptrtmp);
fs->cfa_offset = (saddr)ptrtmp;
fs->cfa_how = CFA_REG_OFFSET; fs->cfa_how = CFA_REG_OFFSET;
break; break;
case DW_CFA_def_cfa_offset_sf: case DW_CFA_def_cfa_offset_sf:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_sleb128 (insn_ptr, &fs->cfa_offset);
fs->cfa_offset = ptrtmp;
/* cfa_how deliberately not set. */ /* cfa_how deliberately not set. */
break; break;
@ -865,16 +857,15 @@ execute_cfa_program (const unsigned char *insn_ptr,
break; break;
case DW_CFA_GNU_args_size: case DW_CFA_GNU_args_size:
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &context->args_size);
context->args_size = ptrtmp;
break; break;
case DW_CFA_GNU_negative_offset_extended: case DW_CFA_GNU_negative_offset_extended:
/* Obsoleted by DW_CFA_offset_extended_sf, but used by /* Obsoleted by DW_CFA_offset_extended_sf, but used by
older PowerPC code. */ older PowerPC code. */
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); reg = ptrtmp; insn_ptr = read_uleb128 (insn_ptr, &reg);
insn_ptr = read_uleb128 (insn_ptr, &ptrtmp); insn_ptr = read_uleb128 (insn_ptr, &utmp);
offset = ptrtmp * fs->data_align; offset = (_Unwind_Word)utmp * fs->data_align;
fs->regs.reg[reg].how = REG_SAVED_OFFSET; fs->regs.reg[reg].how = REG_SAVED_OFFSET;
fs->regs.reg[reg].loc.offset = -offset; fs->regs.reg[reg].loc.offset = -offset;
break; break;
@ -930,7 +921,7 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs)
insn = NULL; insn = NULL;
if (fs->saw_z) if (fs->saw_z)
{ {
_Unwind_Ptr i; _Unwind_Word i;
aug = read_uleb128 (aug, &i); aug = read_uleb128 (aug, &i);
insn = aug + i; insn = aug + i;
} }
@ -1039,7 +1030,7 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
that this will not be a problem. */ that this will not be a problem. */
{ {
const unsigned char *exp = fs->cfa_exp; const unsigned char *exp = fs->cfa_exp;
_Unwind_Ptr len; _Unwind_Word len;
exp = read_uleb128 (exp, &len); exp = read_uleb128 (exp, &len);
cfa = (void *) (_Unwind_Ptr) cfa = (void *) (_Unwind_Ptr)
@ -1067,7 +1058,7 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs)
case REG_SAVED_EXP: case REG_SAVED_EXP:
{ {
const unsigned char *exp = fs->regs.reg[i].loc.exp; const unsigned char *exp = fs->regs.reg[i].loc.exp;
_Unwind_Ptr len; _Unwind_Word len;
_Unwind_Ptr val; _Unwind_Ptr val;
exp = read_uleb128 (exp, &len); exp = read_uleb128 (exp, &len);

99
gcc/unwind-pe.h
View File

@ -108,6 +108,57 @@ base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context)
#endif #endif
/* Read an unsigned leb128 value from P, store the value in VAL, return
P incremented past the value. We assume that a word is large enough to
hold any value so encoded; if it is smaller than a pointer on some target,
pointers should not be leb128 encoded on that target. */
static const unsigned char *
read_uleb128 (const unsigned char *p, _Unwind_Word *val)
{
unsigned int shift = 0;
unsigned char byte;
_Unwind_Word result;
result = 0;
do
{
byte = *p++;
result |= (byte & 0x7f) << shift;
shift += 7;
}
while (byte & 0x80);
*val = result;
return p;
}
/* Similar, but read a signed leb128 value. */
static const unsigned char *
read_sleb128 (const unsigned char *p, _Unwind_Sword *val)
{
unsigned int shift = 0;
unsigned char byte;
_Unwind_Word result;
result = 0;
do
{
byte = *p++;
result |= (byte & 0x7f) << shift;
shift += 7;
}
while (byte & 0x80);
/* Sign-extend a negative value. */
if (shift < 8 * sizeof(result) && (byte & 0x40) != 0)
result |= -(1L << shift);
*val = (_Unwind_Sword) result;
return p;
}
/* Load an encoded value from memory at P. The value is returned in VAL; /* Load an encoded value from memory at P. The value is returned in VAL;
The function returns P incremented past the value. BASE is as given The function returns P incremented past the value. BASE is as given
by base_of_encoded_value for this encoding in the appropriate context. */ by base_of_encoded_value for this encoding in the appropriate context. */
@ -148,36 +199,17 @@ read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base,
case DW_EH_PE_uleb128: case DW_EH_PE_uleb128:
{ {
unsigned int shift = 0; _Unwind_Word tmp;
unsigned char byte; p = read_uleb128 (p, &tmp);
result = (_Unwind_Ptr)tmp;
result = 0;
do
{
byte = *p++;
result |= (_Unwind_Ptr)(byte & 0x7f) << shift;
shift += 7;
}
while (byte & 0x80);
} }
break; break;
case DW_EH_PE_sleb128: case DW_EH_PE_sleb128:
{ {
unsigned int shift = 0; _Unwind_Sword tmp;
unsigned char byte; p = read_sleb128 (p, &tmp);
result = (_Unwind_Ptr)tmp;
result = 0;
do
{
byte = *p++;
result |= (_Unwind_Ptr)(byte & 0x7f) << shift;
shift += 7;
}
while (byte & 0x80);
if (shift < 8 * sizeof(result) && (byte & 0x40) != 0)
result |= -(1L << shift);
} }
break; break;
@ -239,20 +271,3 @@ read_encoded_value (struct _Unwind_Context *context, unsigned char encoding,
} }
#endif #endif
/* Read an unsigned leb128 value from P, store the value in VAL, return
P incremented past the value. */
static inline const unsigned char *
read_uleb128 (const unsigned char *p, _Unwind_Ptr *val)
{
return read_encoded_value_with_base (DW_EH_PE_uleb128, 0, p, val);
}
/* Similar, but read a signed leb128 value. */
static inline const unsigned char *
read_sleb128 (const unsigned char *p, _Unwind_Ptr *val)
{
return read_encoded_value_with_base (DW_EH_PE_sleb128, 0, p, val);
}

5
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,8 @@
2001-08-31 Jason Merrill <jason_merrill@redhat.com>
* libsupc++/eh_personality.cc (PERSONALITY_FUNCTION): Simplify
leb128 handling.
2001-08-28 Loren J. Rittle <ljrittle@acm.org> 2001-08-28 Loren J. Rittle <ljrittle@acm.org>
* include/Makefile.am: Use toplevel_srcdir to refer to src files * include/Makefile.am: Use toplevel_srcdir to refer to src files

14
libstdc++-v3/libsupc++/eh_personality.cc
View File

@ -84,7 +84,7 @@ parse_lsda_header (_Unwind_Context *context, const unsigned char *p,
} }
static const std::type_info * static const std::type_info *
get_ttype_entry (lsda_header_info *info, long i) get_ttype_entry (lsda_header_info *info, _Unwind_Word i)
{ {
_Unwind_Ptr ptr; _Unwind_Ptr ptr;
@ -97,14 +97,14 @@ get_ttype_entry (lsda_header_info *info, long i)
static bool static bool
check_exception_spec (lsda_header_info *info, const std::type_info *throw_type, check_exception_spec (lsda_header_info *info, const std::type_info *throw_type,
long filter_value) _Unwind_Sword filter_value)
{ {
const unsigned char *e = info->TType - filter_value - 1; const unsigned char *e = info->TType - filter_value - 1;
while (1) while (1)
{ {
const std::type_info *catch_type; const std::type_info *catch_type;
_Unwind_Ptr tmp; _Unwind_Word tmp;
void *dummy; void *dummy;
e = read_uleb128 (e, &tmp); e = read_uleb128 (e, &tmp);
@ -262,7 +262,7 @@ PERSONALITY_FUNCTION (int version,
{ {
// Otherwise we have a catch handler or exception specification. // Otherwise we have a catch handler or exception specification.
signed long ar_filter, ar_disp; _Unwind_Sword ar_filter, ar_disp;
const std::type_info *throw_type, *catch_type; const std::type_info *throw_type, *catch_type;
bool saw_cleanup = false; bool saw_cleanup = false;
bool saw_handler = false; bool saw_handler = false;
@ -279,11 +279,9 @@ PERSONALITY_FUNCTION (int version,
while (1) while (1)
{ {
_Unwind_Ptr tmp;
p = action_record; p = action_record;
p = read_sleb128 (p, &tmp); ar_filter = tmp; p = read_sleb128 (p, &ar_filter);
read_sleb128 (p, &tmp); ar_disp = tmp; read_sleb128 (p, &ar_disp);
if (ar_filter == 0) if (ar_filter == 0)
{ {