[PATCH 0/5] MR1134: ntdll: Use local unwinding reimplementations for Unix libraries on ARM/ARM64

List overview All Threads

newer

older

[PATCH v12 0/6] MR1120: Add...

[PATCH 0/1] MR1128: msvcrt:...

Martin Storsjö (＠mstorsjo)

21 Oct 2022 21 Oct '22

10:03 a.m.

Currently, unwinding the unix libraries (or full ELF builds) requires having libunwind available.

When starting up a wine environment, an exception of type `RPC_S_SERVER_UNAVAILABLE` gets thrown - and if libunwind isn't available, this breaks the startup. Thus, currently on ARM/ARM64, libunwind is essentially mandatory.

Additionally, at least on ARM, libunwind seems brittle (commits in latest git master breaks the unwinding use cases in Wine, see e.g. https://github.com/libunwind/libunwind/pull/203#issuecomment-984126066.

This MR tries to resolve all of this, by including the preexisting DWARF parser from x86_64 in the aarch64 version too. This bit was mostly quite straightforward.

For ARM, libunwind has currently relied on DWARF debug info in the `.debug_frame` section, since Linux on ARM doesn't use DWARF for runtime unwinding. This MR adds ARM EHABI unwind opcodes where necessary, and adds a local reimplementation of an ARM EHABI/EXIDX/EXTBL unwinder, similar to the DWARF one.

With these changes, unwinding on both ARM and ARM64 seems to work fine, even without libunwind.

See the individual commit messages for more commentary on the decisions taken so far (I've tried to write up all relevant considerations there - it's a fair amount of commentery).

A couple open questions: - So far, the shared DWARF code was put in a header, `dwarf.h`. Do you want to make this a proper standalone `.c` file too? - I wrote the ARM EHABI unwind code mostly with `stdint.h` types like `uint32_t`(as it's in the ntdll/unix directory anyway), but I can rewrite it with `DWORD` or similar if that's preferred. - The ARM EHABI opcodes are enabled for `defined(__arm__) && defined(__ELF__) && defined(__GNUC__) && !defined(__SEH__) && !defined(__ARM_DWARF_EH__)` - there's no define to check for for knowing it's used and enabled, but it has to be implicitly assumed if no other other unwind mechanism is signaled. - The `dl_iterate_phdr` function, used for finding the EXIDX section for locating ARM EHABI unwind info, is used within `#ifdef linux`. It might be available on other OSes too (like FreeBSD etc). Or should I go ahead and add a configure check for it?

CC @julliard @rbernon @AndreRH

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Show replies by date

Martin Storsjö

21 Oct 21 Oct

10:03 a.m.

New subject: [PATCH 1/5] ntdll: Move the dwarf reading routines to a shareable header

From: Martin Storsjö martin@martin.st

Alternatively the implementations could reside in their own standalone .c file, but this was the least amount of effort.

Signed-off-by: Martin Storsjö martin@martin.st --- dlls/ntdll/unix/dwarf.h | 849 ++++++++++++++++++++++++++++++++ dlls/ntdll/unix/signal_x86_64.c | 823 +------------------------------ 2 files changed, 851 insertions(+), 821 deletions(-) create mode 100644 dlls/ntdll/unix/dwarf.h

diff --git a/dlls/ntdll/unix/dwarf.h b/dlls/ntdll/unix/dwarf.h new file mode 100644 index 00000000000..33cc8315bd6 --- /dev/null +++ b/dlls/ntdll/unix/dwarf.h @@ -0,0 +1,849 @@ +/* + * DWARF unwinding routines + * + * Copyright 2009 Alexandre Julliard + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#ifndef __NTDLL_DWARF_H +#define __NTDLL_DWARF_H + +#define WIN32_NO_STATUS +#include "windef.h" +#include "winnt.h" + +/*********************************************************************** + * Definitions for Dwarf unwind tables + */ + +#define DW_CFA_advance_loc 0x40 +#define DW_CFA_offset 0x80 +#define DW_CFA_restore 0xc0 +#define DW_CFA_nop 0x00 +#define DW_CFA_set_loc 0x01 +#define DW_CFA_advance_loc1 0x02 +#define DW_CFA_advance_loc2 0x03 +#define DW_CFA_advance_loc4 0x04 +#define DW_CFA_offset_extended 0x05 +#define DW_CFA_restore_extended 0x06 +#define DW_CFA_undefined 0x07 +#define DW_CFA_same_value 0x08 +#define DW_CFA_register 0x09 +#define DW_CFA_remember_state 0x0a +#define DW_CFA_restore_state 0x0b +#define DW_CFA_def_cfa 0x0c +#define DW_CFA_def_cfa_register 0x0d +#define DW_CFA_def_cfa_offset 0x0e +#define DW_CFA_def_cfa_expression 0x0f +#define DW_CFA_expression 0x10 +#define DW_CFA_offset_extended_sf 0x11 +#define DW_CFA_def_cfa_sf 0x12 +#define DW_CFA_def_cfa_offset_sf 0x13 +#define DW_CFA_val_offset 0x14 +#define DW_CFA_val_offset_sf 0x15 +#define DW_CFA_val_expression 0x16 + +#define DW_OP_addr 0x03 +#define DW_OP_deref 0x06 +#define DW_OP_const1u 0x08 +#define DW_OP_const1s 0x09 +#define DW_OP_const2u 0x0a +#define DW_OP_const2s 0x0b +#define DW_OP_const4u 0x0c +#define DW_OP_const4s 0x0d +#define DW_OP_const8u 0x0e +#define DW_OP_const8s 0x0f +#define DW_OP_constu 0x10 +#define DW_OP_consts 0x11 +#define DW_OP_dup 0x12 +#define DW_OP_drop 0x13 +#define DW_OP_over 0x14 +#define DW_OP_pick 0x15 +#define DW_OP_swap 0x16 +#define DW_OP_rot 0x17 +#define DW_OP_xderef 0x18 +#define DW_OP_abs 0x19 +#define DW_OP_and 0x1a +#define DW_OP_div 0x1b +#define DW_OP_minus 0x1c +#define DW_OP_mod 0x1d +#define DW_OP_mul 0x1e +#define DW_OP_neg 0x1f +#define DW_OP_not 0x20 +#define DW_OP_or 0x21 +#define DW_OP_plus 0x22 +#define DW_OP_plus_uconst 0x23 +#define DW_OP_shl 0x24 +#define DW_OP_shr 0x25 +#define DW_OP_shra 0x26 +#define DW_OP_xor 0x27 +#define DW_OP_bra 0x28 +#define DW_OP_eq 0x29 +#define DW_OP_ge 0x2a +#define DW_OP_gt 0x2b +#define DW_OP_le 0x2c +#define DW_OP_lt 0x2d +#define DW_OP_ne 0x2e +#define DW_OP_skip 0x2f +#define DW_OP_lit0 0x30 +#define DW_OP_lit1 0x31 +#define DW_OP_lit2 0x32 +#define DW_OP_lit3 0x33 +#define DW_OP_lit4 0x34 +#define DW_OP_lit5 0x35 +#define DW_OP_lit6 0x36 +#define DW_OP_lit7 0x37 +#define DW_OP_lit8 0x38 +#define DW_OP_lit9 0x39 +#define DW_OP_lit10 0x3a +#define DW_OP_lit11 0x3b +#define DW_OP_lit12 0x3c +#define DW_OP_lit13 0x3d +#define DW_OP_lit14 0x3e +#define DW_OP_lit15 0x3f +#define DW_OP_lit16 0x40 +#define DW_OP_lit17 0x41 +#define DW_OP_lit18 0x42 +#define DW_OP_lit19 0x43 +#define DW_OP_lit20 0x44 +#define DW_OP_lit21 0x45 +#define DW_OP_lit22 0x46 +#define DW_OP_lit23 0x47 +#define DW_OP_lit24 0x48 +#define DW_OP_lit25 0x49 +#define DW_OP_lit26 0x4a +#define DW_OP_lit27 0x4b +#define DW_OP_lit28 0x4c +#define DW_OP_lit29 0x4d +#define DW_OP_lit30 0x4e +#define DW_OP_lit31 0x4f +#define DW_OP_reg0 0x50 +#define DW_OP_reg1 0x51 +#define DW_OP_reg2 0x52 +#define DW_OP_reg3 0x53 +#define DW_OP_reg4 0x54 +#define DW_OP_reg5 0x55 +#define DW_OP_reg6 0x56 +#define DW_OP_reg7 0x57 +#define DW_OP_reg8 0x58 +#define DW_OP_reg9 0x59 +#define DW_OP_reg10 0x5a +#define DW_OP_reg11 0x5b +#define DW_OP_reg12 0x5c +#define DW_OP_reg13 0x5d +#define DW_OP_reg14 0x5e +#define DW_OP_reg15 0x5f +#define DW_OP_reg16 0x60 +#define DW_OP_reg17 0x61 +#define DW_OP_reg18 0x62 +#define DW_OP_reg19 0x63 +#define DW_OP_reg20 0x64 +#define DW_OP_reg21 0x65 +#define DW_OP_reg22 0x66 +#define DW_OP_reg23 0x67 +#define DW_OP_reg24 0x68 +#define DW_OP_reg25 0x69 +#define DW_OP_reg26 0x6a +#define DW_OP_reg27 0x6b +#define DW_OP_reg28 0x6c +#define DW_OP_reg29 0x6d +#define DW_OP_reg30 0x6e +#define DW_OP_reg31 0x6f +#define DW_OP_breg0 0x70 +#define DW_OP_breg1 0x71 +#define DW_OP_breg2 0x72 +#define DW_OP_breg3 0x73 +#define DW_OP_breg4 0x74 +#define DW_OP_breg5 0x75 +#define DW_OP_breg6 0x76 +#define DW_OP_breg7 0x77 +#define DW_OP_breg8 0x78 +#define DW_OP_breg9 0x79 +#define DW_OP_breg10 0x7a +#define DW_OP_breg11 0x7b +#define DW_OP_breg12 0x7c +#define DW_OP_breg13 0x7d +#define DW_OP_breg14 0x7e +#define DW_OP_breg15 0x7f +#define DW_OP_breg16 0x80 +#define DW_OP_breg17 0x81 +#define DW_OP_breg18 0x82 +#define DW_OP_breg19 0x83 +#define DW_OP_breg20 0x84 +#define DW_OP_breg21 0x85 +#define DW_OP_breg22 0x86 +#define DW_OP_breg23 0x87 +#define DW_OP_breg24 0x88 +#define DW_OP_breg25 0x89 +#define DW_OP_breg26 0x8a +#define DW_OP_breg27 0x8b +#define DW_OP_breg28 0x8c +#define DW_OP_breg29 0x8d +#define DW_OP_breg30 0x8e +#define DW_OP_breg31 0x8f +#define DW_OP_regx 0x90 +#define DW_OP_fbreg 0x91 +#define DW_OP_bregx 0x92 +#define DW_OP_piece 0x93 +#define DW_OP_deref_size 0x94 +#define DW_OP_xderef_size 0x95 +#define DW_OP_nop 0x96 +#define DW_OP_push_object_address 0x97 +#define DW_OP_call2 0x98 +#define DW_OP_call4 0x99 +#define DW_OP_call_ref 0x9a +#define DW_OP_form_tls_address 0x9b +#define DW_OP_call_frame_cfa 0x9c +#define DW_OP_bit_piece 0x9d +#define DW_OP_lo_user 0xe0 +#define DW_OP_hi_user 0xff +#define DW_OP_GNU_push_tls_address 0xe0 +#define DW_OP_GNU_uninit 0xf0 +#define DW_OP_GNU_encoded_addr 0xf1 + +#define DW_EH_PE_native 0x00 +#define DW_EH_PE_uleb128 0x01 +#define DW_EH_PE_udata2 0x02 +#define DW_EH_PE_udata4 0x03 +#define DW_EH_PE_udata8 0x04 +#define DW_EH_PE_sleb128 0x09 +#define DW_EH_PE_sdata2 0x0a +#define DW_EH_PE_sdata4 0x0b +#define DW_EH_PE_sdata8 0x0c +#define DW_EH_PE_signed 0x08 +#define DW_EH_PE_abs 0x00 +#define DW_EH_PE_pcrel 0x10 +#define DW_EH_PE_textrel 0x20 +#define DW_EH_PE_datarel 0x30 +#define DW_EH_PE_funcrel 0x40 +#define DW_EH_PE_aligned 0x50 +#define DW_EH_PE_indirect 0x80 +#define DW_EH_PE_omit 0xff + +struct dwarf_eh_bases +{ + void *tbase; + void *dbase; + void *func; +}; + +struct dwarf_cie +{ + unsigned int length; + int id; + unsigned char version; + unsigned char augmentation[1]; +}; + +struct dwarf_fde +{ + unsigned int length; + unsigned int cie_offset; +}; + +extern const struct dwarf_fde *_Unwind_Find_FDE (void *, struct dwarf_eh_bases *); + +static unsigned char dwarf_get_u1( const unsigned char **p ) +{ + return *(*p)++; +} + +static unsigned short dwarf_get_u2( const unsigned char **p ) +{ + unsigned int ret = (*p)[0] | ((*p)[1] << 8); + (*p) += 2; + return ret; +} + +static unsigned int dwarf_get_u4( const unsigned char **p ) +{ + unsigned int ret = (*p)[0] | ((*p)[1] << 8) | ((*p)[2] << 16) | ((*p)[3] << 24); + (*p) += 4; + return ret; +} + +static ULONG64 dwarf_get_u8( const unsigned char **p ) +{ + ULONG64 low = dwarf_get_u4( p ); + ULONG64 high = dwarf_get_u4( p ); + return low | (high << 32); +} + +static ULONG_PTR dwarf_get_uleb128( const unsigned char **p ) +{ + ULONG_PTR ret = 0; + unsigned int shift = 0; + unsigned char byte; + + do + { + byte = **p; + ret |= (ULONG_PTR)(byte & 0x7f) << shift; + shift += 7; + (*p)++; + } while (byte & 0x80); + return ret; +} + +static LONG_PTR dwarf_get_sleb128( const unsigned char **p ) +{ + ULONG_PTR ret = 0; + unsigned int shift = 0; + unsigned char byte; + + do + { + byte = **p; + ret |= (ULONG_PTR)(byte & 0x7f) << shift; + shift += 7; + (*p)++; + } while (byte & 0x80); + + if ((shift < 8 * sizeof(ret)) && (byte & 0x40)) ret |= -((ULONG_PTR)1 << shift); + return ret; +} + +static ULONG_PTR dwarf_get_ptr( const unsigned char **p, unsigned char encoding, const struct dwarf_eh_bases *bases ) +{ + ULONG_PTR base; + + if (encoding == DW_EH_PE_omit) return 0; + + switch (encoding & 0x70) + { + case DW_EH_PE_abs: + base = 0; + break; + case DW_EH_PE_pcrel: + base = (ULONG_PTR)*p; + break; + case DW_EH_PE_textrel: + base = (ULONG_PTR)bases->tbase; + break; + case DW_EH_PE_datarel: + base = (ULONG_PTR)bases->dbase; + break; + case DW_EH_PE_funcrel: + base = (ULONG_PTR)bases->func; + break; + case DW_EH_PE_aligned: + base = ((ULONG_PTR)*p + 7) & ~7ul; + break; + default: + FIXME( "unsupported encoding %02x\n", encoding ); + return 0; + } + + switch (encoding & 0x0f) + { + case DW_EH_PE_native: base += dwarf_get_u8( p ); break; + case DW_EH_PE_uleb128: base += dwarf_get_uleb128( p ); break; + case DW_EH_PE_udata2: base += dwarf_get_u2( p ); break; + case DW_EH_PE_udata4: base += dwarf_get_u4( p ); break; + case DW_EH_PE_udata8: base += dwarf_get_u8( p ); break; + case DW_EH_PE_sleb128: base += dwarf_get_sleb128( p ); break; + case DW_EH_PE_sdata2: base += (signed short)dwarf_get_u2( p ); break; + case DW_EH_PE_sdata4: base += (signed int)dwarf_get_u4( p ); break; + case DW_EH_PE_sdata8: base += (LONG64)dwarf_get_u8( p ); break; + default: + FIXME( "unsupported encoding %02x\n", encoding ); + return 0; + } + if (encoding & DW_EH_PE_indirect) base = *(ULONG_PTR *)base; + return base; +} + +enum reg_rule +{ + RULE_UNSET, /* not set at all */ + RULE_UNDEFINED, /* undefined value */ + RULE_SAME, /* same value as previous frame */ + RULE_CFA_OFFSET, /* stored at cfa offset */ + RULE_OTHER_REG, /* stored in other register */ + RULE_EXPRESSION, /* address specified by expression */ + RULE_VAL_EXPRESSION /* value specified by expression */ +}; + +#define NB_FRAME_REGS 41 +#define MAX_SAVED_STATES 16 + +struct frame_state +{ + ULONG_PTR cfa_offset; + unsigned char cfa_reg; + enum reg_rule cfa_rule; + enum reg_rule rules[NB_FRAME_REGS]; + ULONG64 regs[NB_FRAME_REGS]; +}; + +struct frame_info +{ + ULONG_PTR ip; + ULONG_PTR code_align; + LONG_PTR data_align; + unsigned char retaddr_reg; + unsigned char fde_encoding; + unsigned char signal_frame; + unsigned char state_sp; + struct frame_state state; + struct frame_state *state_stack; +}; + +static const char *dwarf_reg_names[NB_FRAME_REGS] = +{ +/* 0-7 */ "%rax", "%rdx", "%rcx", "%rbx", "%rsi", "%rdi", "%rbp", "%rsp", +/* 8-16 */ "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "%rip", +/* 17-24 */ "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", +/* 25-32 */ "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", +/* 33-40 */ "%st0", "%st1", "%st2", "%st3", "%st4", "%st5", "%st6", "%st7" +}; + +static BOOL valid_reg( ULONG_PTR reg ) +{ + if (reg >= NB_FRAME_REGS) FIXME( "unsupported reg %lx\n", reg ); + return (reg < NB_FRAME_REGS); +} + +static void execute_cfa_instructions( const unsigned char *ptr, const unsigned char *end, + ULONG_PTR last_ip, struct frame_info *info, + const struct dwarf_eh_bases *bases ) +{ + while (ptr < end && info->ip < last_ip + info->signal_frame) + { + const unsigned char op = *ptr++; + + if (op & 0xc0) + { + switch (op & 0xc0) + { + case DW_CFA_advance_loc: + { + ULONG_PTR offset = (op & 0x3f) * info->code_align; + TRACE( "%lx: DW_CFA_advance_loc %lu\n", info->ip, offset ); + info->ip += offset; + break; + } + case DW_CFA_offset: + { + ULONG_PTR reg = op & 0x3f; + LONG_PTR offset = dwarf_get_uleb128( &ptr ) * info->data_align; + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_offset %s, %ld\n", info->ip, dwarf_reg_names[reg], offset ); + info->state.regs[reg] = offset; + info->state.rules[reg] = RULE_CFA_OFFSET; + break; + } + case DW_CFA_restore: + { + ULONG_PTR reg = op & 0x3f; + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_restore %s\n", info->ip, dwarf_reg_names[reg] ); + info->state.rules[reg] = RULE_UNSET; + break; + } + } + } + else switch (op) + { + case DW_CFA_nop: + break; + case DW_CFA_set_loc: + { + ULONG_PTR loc = dwarf_get_ptr( &ptr, info->fde_encoding, bases ); + TRACE( "%lx: DW_CFA_set_loc %lx\n", info->ip, loc ); + info->ip = loc; + break; + } + case DW_CFA_advance_loc1: + { + ULONG_PTR offset = *ptr++ * info->code_align; + TRACE( "%lx: DW_CFA_advance_loc1 %lu\n", info->ip, offset ); + info->ip += offset; + break; + } + case DW_CFA_advance_loc2: + { + ULONG_PTR offset = dwarf_get_u2( &ptr ) * info->code_align; + TRACE( "%lx: DW_CFA_advance_loc2 %lu\n", info->ip, offset ); + info->ip += offset; + break; + } + case DW_CFA_advance_loc4: + { + ULONG_PTR offset = dwarf_get_u4( &ptr ) * info->code_align; + TRACE( "%lx: DW_CFA_advance_loc4 %lu\n", info->ip, offset ); + info->ip += offset; + break; + } + case DW_CFA_offset_extended: + case DW_CFA_offset_extended_sf: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + LONG_PTR offset = (op == DW_CFA_offset_extended) ? dwarf_get_uleb128( &ptr ) * info->data_align + : dwarf_get_sleb128( &ptr ) * info->data_align; + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_offset_extended %s, %ld\n", info->ip, dwarf_reg_names[reg], offset ); + info->state.regs[reg] = offset; + info->state.rules[reg] = RULE_CFA_OFFSET; + break; + } + case DW_CFA_restore_extended: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_restore_extended %s\n", info->ip, dwarf_reg_names[reg] ); + info->state.rules[reg] = RULE_UNSET; + break; + } + case DW_CFA_undefined: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_undefined %s\n", info->ip, dwarf_reg_names[reg] ); + info->state.rules[reg] = RULE_UNDEFINED; + break; + } + case DW_CFA_same_value: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_same_value %s\n", info->ip, dwarf_reg_names[reg] ); + info->state.regs[reg] = reg; + info->state.rules[reg] = RULE_SAME; + break; + } + case DW_CFA_register: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + ULONG_PTR reg2 = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg ) || !valid_reg( reg2 )) break; + TRACE( "%lx: DW_CFA_register %s == %s\n", info->ip, dwarf_reg_names[reg], dwarf_reg_names[reg2] ); + info->state.regs[reg] = reg2; + info->state.rules[reg] = RULE_OTHER_REG; + break; + } + case DW_CFA_remember_state: + TRACE( "%lx: DW_CFA_remember_state\n", info->ip ); + if (info->state_sp >= MAX_SAVED_STATES) + FIXME( "%lx: DW_CFA_remember_state too many nested saves\n", info->ip ); + else + info->state_stack[info->state_sp++] = info->state; + break; + case DW_CFA_restore_state: + TRACE( "%lx: DW_CFA_restore_state\n", info->ip ); + if (!info->state_sp) + FIXME( "%lx: DW_CFA_restore_state without corresponding save\n", info->ip ); + else + info->state = info->state_stack[--info->state_sp]; + break; + case DW_CFA_def_cfa: + case DW_CFA_def_cfa_sf: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + ULONG_PTR offset = (op == DW_CFA_def_cfa) ? dwarf_get_uleb128( &ptr ) + : dwarf_get_sleb128( &ptr ) * info->data_align; + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_def_cfa %s, %lu\n", info->ip, dwarf_reg_names[reg], offset ); + info->state.cfa_reg = reg; + info->state.cfa_offset = offset; + info->state.cfa_rule = RULE_CFA_OFFSET; + break; + } + case DW_CFA_def_cfa_register: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_def_cfa_register %s\n", info->ip, dwarf_reg_names[reg] ); + info->state.cfa_reg = reg; + info->state.cfa_rule = RULE_CFA_OFFSET; + break; + } + case DW_CFA_def_cfa_offset: + case DW_CFA_def_cfa_offset_sf: + { + ULONG_PTR offset = (op == DW_CFA_def_cfa_offset) ? dwarf_get_uleb128( &ptr ) + : dwarf_get_sleb128( &ptr ) * info->data_align; + TRACE( "%lx: DW_CFA_def_cfa_offset %lu\n", info->ip, offset ); + info->state.cfa_offset = offset; + info->state.cfa_rule = RULE_CFA_OFFSET; + break; + } + case DW_CFA_def_cfa_expression: + { + ULONG_PTR expr = (ULONG_PTR)ptr; + ULONG_PTR len = dwarf_get_uleb128( &ptr ); + TRACE( "%lx: DW_CFA_def_cfa_expression %lx-%lx\n", info->ip, expr, expr+len ); + info->state.cfa_offset = expr; + info->state.cfa_rule = RULE_VAL_EXPRESSION; + ptr += len; + break; + } + case DW_CFA_expression: + case DW_CFA_val_expression: + { + ULONG_PTR reg = dwarf_get_uleb128( &ptr ); + ULONG_PTR expr = (ULONG_PTR)ptr; + ULONG_PTR len = dwarf_get_uleb128( &ptr ); + if (!valid_reg( reg )) break; + TRACE( "%lx: DW_CFA_%sexpression %s %lx-%lx\n", + info->ip, (op == DW_CFA_expression) ? "" : "val_", dwarf_reg_names[reg], expr, expr+len ); + info->state.regs[reg] = expr; + info->state.rules[reg] = (op == DW_CFA_expression) ? RULE_EXPRESSION : RULE_VAL_EXPRESSION; + ptr += len; + break; + } + default: + FIXME( "%lx: unknown CFA opcode %02x\n", info->ip, op ); + break; + } + } +} + +/* retrieve a context register from its dwarf number */ +static void *get_context_reg( CONTEXT *context, ULONG_PTR dw_reg ) +{ + switch (dw_reg) + { + case 0: return &context->Rax; + case 1: return &context->Rdx; + case 2: return &context->Rcx; + case 3: return &context->Rbx; + case 4: return &context->Rsi; + case 5: return &context->Rdi; + case 6: return &context->Rbp; + case 7: return &context->Rsp; + case 8: return &context->R8; + case 9: return &context->R9; + case 10: return &context->R10; + case 11: return &context->R11; + case 12: return &context->R12; + case 13: return &context->R13; + case 14: return &context->R14; + case 15: return &context->R15; + case 16: return &context->Rip; + case 17: return &context->u.s.Xmm0; + case 18: return &context->u.s.Xmm1; + case 19: return &context->u.s.Xmm2; + case 20: return &context->u.s.Xmm3; + case 21: return &context->u.s.Xmm4; + case 22: return &context->u.s.Xmm5; + case 23: return &context->u.s.Xmm6; + case 24: return &context->u.s.Xmm7; + case 25: return &context->u.s.Xmm8; + case 26: return &context->u.s.Xmm9; + case 27: return &context->u.s.Xmm10; + case 28: return &context->u.s.Xmm11; + case 29: return &context->u.s.Xmm12; + case 30: return &context->u.s.Xmm13; + case 31: return &context->u.s.Xmm14; + case 32: return &context->u.s.Xmm15; + case 33: return &context->u.s.Legacy[0]; + case 34: return &context->u.s.Legacy[1]; + case 35: return &context->u.s.Legacy[2]; + case 36: return &context->u.s.Legacy[3]; + case 37: return &context->u.s.Legacy[4]; + case 38: return &context->u.s.Legacy[5]; + case 39: return &context->u.s.Legacy[6]; + case 40: return &context->u.s.Legacy[7]; + default: return NULL; + } +} + +/* set a context register from its dwarf number */ +static void set_context_reg( CONTEXT *context, ULONG_PTR dw_reg, void *val ) +{ + switch (dw_reg) + { + case 0: context->Rax = *(ULONG64 *)val; break; + case 1: context->Rdx = *(ULONG64 *)val; break; + case 2: context->Rcx = *(ULONG64 *)val; break; + case 3: context->Rbx = *(ULONG64 *)val; break; + case 4: context->Rsi = *(ULONG64 *)val; break; + case 5: context->Rdi = *(ULONG64 *)val; break; + case 6: context->Rbp = *(ULONG64 *)val; break; + case 7: context->Rsp = *(ULONG64 *)val; break; + case 8: context->R8 = *(ULONG64 *)val; break; + case 9: context->R9 = *(ULONG64 *)val; break; + case 10: context->R10 = *(ULONG64 *)val; break; + case 11: context->R11 = *(ULONG64 *)val; break; + case 12: context->R12 = *(ULONG64 *)val; break; + case 13: context->R13 = *(ULONG64 *)val; break; + case 14: context->R14 = *(ULONG64 *)val; break; + case 15: context->R15 = *(ULONG64 *)val; break; + case 16: context->Rip = *(ULONG64 *)val; break; + case 17: memcpy( &context->u.s.Xmm0, val, sizeof(M128A) ); break; + case 18: memcpy( &context->u.s.Xmm1, val, sizeof(M128A) ); break; + case 19: memcpy( &context->u.s.Xmm2, val, sizeof(M128A) ); break; + case 20: memcpy( &context->u.s.Xmm3, val, sizeof(M128A) ); break; + case 21: memcpy( &context->u.s.Xmm4, val, sizeof(M128A) ); break; + case 22: memcpy( &context->u.s.Xmm5, val, sizeof(M128A) ); break; + case 23: memcpy( &context->u.s.Xmm6, val, sizeof(M128A) ); break; + case 24: memcpy( &context->u.s.Xmm7, val, sizeof(M128A) ); break; + case 25: memcpy( &context->u.s.Xmm8, val, sizeof(M128A) ); break; + case 26: memcpy( &context->u.s.Xmm9, val, sizeof(M128A) ); break; + case 27: memcpy( &context->u.s.Xmm10, val, sizeof(M128A) ); break; + case 28: memcpy( &context->u.s.Xmm11, val, sizeof(M128A) ); break; + case 29: memcpy( &context->u.s.Xmm12, val, sizeof(M128A) ); break; + case 30: memcpy( &context->u.s.Xmm13, val, sizeof(M128A) ); break; + case 31: memcpy( &context->u.s.Xmm14, val, sizeof(M128A) ); break; + case 32: memcpy( &context->u.s.Xmm15, val, sizeof(M128A) ); break; + case 33: memcpy( &context->u.s.Legacy[0], val, sizeof(M128A) ); break; + case 34: memcpy( &context->u.s.Legacy[1], val, sizeof(M128A) ); break; + case 35: memcpy( &context->u.s.Legacy[2], val, sizeof(M128A) ); break; + case 36: memcpy( &context->u.s.Legacy[3], val, sizeof(M128A) ); break; + case 37: memcpy( &context->u.s.Legacy[4], val, sizeof(M128A) ); break; + case 38: memcpy( &context->u.s.Legacy[5], val, sizeof(M128A) ); break; + case 39: memcpy( &context->u.s.Legacy[6], val, sizeof(M128A) ); break; + case 40: memcpy( &context->u.s.Legacy[7], val, sizeof(M128A) ); break; + } +} + +static ULONG_PTR eval_expression( const unsigned char *p, CONTEXT *context, + const struct dwarf_eh_bases *bases ) +{ + ULONG_PTR reg, tmp, stack[64]; + int sp = -1; + ULONG_PTR len = dwarf_get_uleb128(&p); + const unsigned char *end = p + len; + + while (p < end) + { + unsigned char opcode = dwarf_get_u1(&p); + + if (opcode >= DW_OP_lit0 && opcode <= DW_OP_lit31) + stack[++sp] = opcode - DW_OP_lit0; + else if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) + stack[++sp] = *(ULONG_PTR *)get_context_reg( context, opcode - DW_OP_reg0 ); + else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) + stack[++sp] = *(ULONG_PTR *)get_context_reg( context, opcode - DW_OP_breg0 ) + dwarf_get_sleb128(&p); + else switch (opcode) + { + case DW_OP_nop: break; + case DW_OP_addr: stack[++sp] = dwarf_get_u8(&p); break; + case DW_OP_const1u: stack[++sp] = dwarf_get_u1(&p); break; + case DW_OP_const1s: stack[++sp] = (signed char)dwarf_get_u1(&p); break; + case DW_OP_const2u: stack[++sp] = dwarf_get_u2(&p); break; + case DW_OP_const2s: stack[++sp] = (short)dwarf_get_u2(&p); break; + case DW_OP_const4u: stack[++sp] = dwarf_get_u4(&p); break; + case DW_OP_const4s: stack[++sp] = (signed int)dwarf_get_u4(&p); break; + case DW_OP_const8u: stack[++sp] = dwarf_get_u8(&p); break; + case DW_OP_const8s: stack[++sp] = (LONG_PTR)dwarf_get_u8(&p); break; + case DW_OP_constu: stack[++sp] = dwarf_get_uleb128(&p); break; + case DW_OP_consts: stack[++sp] = dwarf_get_sleb128(&p); break; + case DW_OP_deref: stack[sp] = *(ULONG_PTR *)stack[sp]; break; + case DW_OP_dup: stack[sp + 1] = stack[sp]; sp++; break; + case DW_OP_drop: sp--; break; + case DW_OP_over: stack[sp + 1] = stack[sp - 1]; sp++; break; + case DW_OP_pick: stack[sp + 1] = stack[sp - dwarf_get_u1(&p)]; sp++; break; + case DW_OP_swap: tmp = stack[sp]; stack[sp] = stack[sp-1]; stack[sp-1] = tmp; break; + case DW_OP_rot: tmp = stack[sp]; stack[sp] = stack[sp-1]; stack[sp-1] = stack[sp-2]; stack[sp-2] = tmp; break; + case DW_OP_abs: stack[sp] = labs(stack[sp]); break; + case DW_OP_neg: stack[sp] = -stack[sp]; break; + case DW_OP_not: stack[sp] = ~stack[sp]; break; + case DW_OP_and: stack[sp-1] &= stack[sp]; sp--; break; + case DW_OP_or: stack[sp-1] |= stack[sp]; sp--; break; + case DW_OP_minus: stack[sp-1] -= stack[sp]; sp--; break; + case DW_OP_mul: stack[sp-1] *= stack[sp]; sp--; break; + case DW_OP_plus: stack[sp-1] += stack[sp]; sp--; break; + case DW_OP_xor: stack[sp-1] ^= stack[sp]; sp--; break; + case DW_OP_shl: stack[sp-1] <<= stack[sp]; sp--; break; + case DW_OP_shr: stack[sp-1] >>= stack[sp]; sp--; break; + case DW_OP_plus_uconst: stack[sp] += dwarf_get_uleb128(&p); break; + case DW_OP_shra: stack[sp-1] = (LONG_PTR)stack[sp-1] / (1 << stack[sp]); sp--; break; + case DW_OP_div: stack[sp-1] = (LONG_PTR)stack[sp-1] / (LONG_PTR)stack[sp]; sp--; break; + case DW_OP_mod: stack[sp-1] = (LONG_PTR)stack[sp-1] % (LONG_PTR)stack[sp]; sp--; break; + case DW_OP_ge: stack[sp-1] = ((LONG_PTR)stack[sp-1] >= (LONG_PTR)stack[sp]); sp--; break; + case DW_OP_gt: stack[sp-1] = ((LONG_PTR)stack[sp-1] > (LONG_PTR)stack[sp]); sp--; break; + case DW_OP_le: stack[sp-1] = ((LONG_PTR)stack[sp-1] <= (LONG_PTR)stack[sp]); sp--; break; + case DW_OP_lt: stack[sp-1] = ((LONG_PTR)stack[sp-1] < (LONG_PTR)stack[sp]); sp--; break; + case DW_OP_eq: stack[sp-1] = (stack[sp-1] == stack[sp]); sp--; break; + case DW_OP_ne: stack[sp-1] = (stack[sp-1] != stack[sp]); sp--; break; + case DW_OP_skip: tmp = (short)dwarf_get_u2(&p); p += tmp; break; + case DW_OP_bra: tmp = (short)dwarf_get_u2(&p); if (!stack[sp--]) p += tmp; break; + case DW_OP_GNU_encoded_addr: tmp = *p++; stack[++sp] = dwarf_get_ptr( &p, tmp, bases ); break; + case DW_OP_regx: stack[++sp] = *(ULONG_PTR *)get_context_reg( context, dwarf_get_uleb128(&p) ); break; + case DW_OP_bregx: + reg = dwarf_get_uleb128(&p); + tmp = dwarf_get_sleb128(&p); + stack[++sp] = *(ULONG_PTR *)get_context_reg( context, reg ) + tmp; + break; + case DW_OP_deref_size: + switch (*p++) + { + case 1: stack[sp] = *(unsigned char *)stack[sp]; break; + case 2: stack[sp] = *(unsigned short *)stack[sp]; break; + case 4: stack[sp] = *(unsigned int *)stack[sp]; break; + case 8: stack[sp] = *(ULONG_PTR *)stack[sp]; break; + } + break; + default: + FIXME( "unhandled opcode %02x\n", opcode ); + } + } + return stack[sp]; +} + +/* apply the computed frame info to the actual context */ +static void apply_frame_state( CONTEXT *context, struct frame_state *state, + const struct dwarf_eh_bases *bases ) +{ + unsigned int i; + ULONG_PTR cfa, value; + CONTEXT new_context = *context; + + switch (state->cfa_rule) + { + case RULE_EXPRESSION: + cfa = *(ULONG_PTR *)eval_expression( (const unsigned char *)state->cfa_offset, context, bases ); + break; + case RULE_VAL_EXPRESSION: + cfa = eval_expression( (const unsigned char *)state->cfa_offset, context, bases ); + break; + default: + cfa = *(ULONG_PTR *)get_context_reg( context, state->cfa_reg ) + state->cfa_offset; + break; + } + if (!cfa) return; + + for (i = 0; i < NB_FRAME_REGS; i++) + { + switch (state->rules[i]) + { + case RULE_UNSET: + case RULE_UNDEFINED: + case RULE_SAME: + break; + case RULE_CFA_OFFSET: + set_context_reg( &new_context, i, (char *)cfa + state->regs[i] ); + break; + case RULE_OTHER_REG: + set_context_reg( &new_context, i, get_context_reg( context, state->regs[i] )); + break; + case RULE_EXPRESSION: + value = eval_expression( (const unsigned char *)state->regs[i], context, bases ); + set_context_reg( &new_context, i, (void *)value ); + break; + case RULE_VAL_EXPRESSION: + value = eval_expression( (const unsigned char *)state->regs[i], context, bases ); + set_context_reg( &new_context, i, &value ); + break; + } + } + new_context.Rsp = cfa; + *context = new_context; +} + +#endif /* __NTDLL_DWARF_H */ diff --git a/dlls/ntdll/unix/signal_x86_64.c b/dlls/ntdll/unix/signal_x86_64.c index 5787f1dc6f9..41f860ac4f4 100644 --- a/dlls/ntdll/unix/signal_x86_64.c +++ b/dlls/ntdll/unix/signal_x86_64.c @@ -80,6 +80,8 @@ WINE_DEFAULT_DEBUG_CHANNEL(unwind); WINE_DECLARE_DEBUG_CHANNEL(seh);

+#include "dwarf.h" + /*********************************************************************** * signal context platform-specific definitions */ @@ -490,827 +492,6 @@ static USHORT cs64_sel; /* selector for %cs in 64-bit mode */ static USHORT ds64_sel; /* selector for %ds/%es/%ss in 64-bit mode */ static USHORT fs32_sel; /* selector for %fs in 32-bit mode */

-/*********************************************************************** - * Definitions for Dwarf unwind tables - */ - -#define DW_CFA_advance_loc 0x40 -#define DW_CFA_offset 0x80 -#define DW_CFA_restore 0xc0 -#define DW_CFA_nop 0x00 -#define DW_CFA_set_loc 0x01 -#define DW_CFA_advance_loc1 0x02 -#define DW_CFA_advance_loc2 0x03 -#define DW_CFA_advance_loc4 0x04 -#define DW_CFA_offset_extended 0x05 -#define DW_CFA_restore_extended 0x06 -#define DW_CFA_undefined 0x07 -#define DW_CFA_same_value 0x08 -#define DW_CFA_register 0x09 -#define DW_CFA_remember_state 0x0a -#define DW_CFA_restore_state 0x0b -#define DW_CFA_def_cfa 0x0c -#define DW_CFA_def_cfa_register 0x0d -#define DW_CFA_def_cfa_offset 0x0e -#define DW_CFA_def_cfa_expression 0x0f -#define DW_CFA_expression 0x10 -#define DW_CFA_offset_extended_sf 0x11 -#define DW_CFA_def_cfa_sf 0x12 -#define DW_CFA_def_cfa_offset_sf 0x13 -#define DW_CFA_val_offset 0x14 -#define DW_CFA_val_offset_sf 0x15 -#define DW_CFA_val_expression 0x16 - -#define DW_OP_addr 0x03 -#define DW_OP_deref 0x06 -#define DW_OP_const1u 0x08 -#define DW_OP_const1s 0x09 -#define DW_OP_const2u 0x0a -#define DW_OP_const2s 0x0b -#define DW_OP_const4u 0x0c -#define DW_OP_const4s 0x0d -#define DW_OP_const8u 0x0e -#define DW_OP_const8s 0x0f -#define DW_OP_constu 0x10 -#define DW_OP_consts 0x11 -#define DW_OP_dup 0x12 -#define DW_OP_drop 0x13 -#define DW_OP_over 0x14 -#define DW_OP_pick 0x15 -#define DW_OP_swap 0x16 -#define DW_OP_rot 0x17 -#define DW_OP_xderef 0x18 -#define DW_OP_abs 0x19 -#define DW_OP_and 0x1a -#define DW_OP_div 0x1b -#define DW_OP_minus 0x1c -#define DW_OP_mod 0x1d -#define DW_OP_mul 0x1e -#define DW_OP_neg 0x1f -#define DW_OP_not 0x20 -#define DW_OP_or 0x21 -#define DW_OP_plus 0x22 -#define DW_OP_plus_uconst 0x23 -#define DW_OP_shl 0x24 -#define DW_OP_shr 0x25 -#define DW_OP_shra 0x26 -#define DW_OP_xor 0x27 -#define DW_OP_bra 0x28 -#define DW_OP_eq 0x29 -#define DW_OP_ge 0x2a -#define DW_OP_gt 0x2b -#define DW_OP_le 0x2c -#define DW_OP_lt 0x2d -#define DW_OP_ne 0x2e -#define DW_OP_skip 0x2f -#define DW_OP_lit0 0x30 -#define DW_OP_lit1 0x31 -#define DW_OP_lit2 0x32 -#define DW_OP_lit3 0x33 -#define DW_OP_lit4 0x34 -#define DW_OP_lit5 0x35 -#define DW_OP_lit6 0x36 -#define DW_OP_lit7 0x37 -#define DW_OP_lit8 0x38 -#define DW_OP_lit9 0x39 -#define DW_OP_lit10 0x3a -#define DW_OP_lit11 0x3b -#define DW_OP_lit12 0x3c -#define DW_OP_lit13 0x3d -#define DW_OP_lit14 0x3e -#define DW_OP_lit15 0x3f -#define DW_OP_lit16 0x40 -#define DW_OP_lit17 0x41 -#define DW_OP_lit18 0x42 -#define DW_OP_lit19 0x43 -#define DW_OP_lit20 0x44 -#define DW_OP_lit21 0x45 -#define DW_OP_lit22 0x46 -#define DW_OP_lit23 0x47 -#define DW_OP_lit24 0x48 -#define DW_OP_lit25 0x49 -#define DW_OP_lit26 0x4a -#define DW_OP_lit27 0x4b -#define DW_OP_lit28 0x4c -#define DW_OP_lit29 0x4d -#define DW_OP_lit30 0x4e -#define DW_OP_lit31 0x4f -#define DW_OP_reg0 0x50 -#define DW_OP_reg1 0x51 -#define DW_OP_reg2 0x52 -#define DW_OP_reg3 0x53 -#define DW_OP_reg4 0x54 -#define DW_OP_reg5 0x55 -#define DW_OP_reg6 0x56 -#define DW_OP_reg7 0x57 -#define DW_OP_reg8 0x58 -#define DW_OP_reg9 0x59 -#define DW_OP_reg10 0x5a -#define DW_OP_reg11 0x5b -#define DW_OP_reg12 0x5c -#define DW_OP_reg13 0x5d -#define DW_OP_reg14 0x5e -#define DW_OP_reg15 0x5f -#define DW_OP_reg16 0x60 -#define DW_OP_reg17 0x61 -#define DW_OP_reg18 0x62 -#define DW_OP_reg19 0x63 -#define DW_OP_reg20 0x64 -#define DW_OP_reg21 0x65 -#define DW_OP_reg22 0x66 -#define DW_OP_reg23 0x67 -#define DW_OP_reg24 0x68 -#define DW_OP_reg25 0x69 -#define DW_OP_reg26 0x6a -#define DW_OP_reg27 0x6b -#define DW_OP_reg28 0x6c -#define DW_OP_reg29 0x6d -#define DW_OP_reg30 0x6e -#define DW_OP_reg31 0x6f -#define DW_OP_breg0 0x70 -#define DW_OP_breg1 0x71 -#define DW_OP_breg2 0x72 -#define DW_OP_breg3 0x73 -#define DW_OP_breg4 0x74 -#define DW_OP_breg5 0x75 -#define DW_OP_breg6 0x76 -#define DW_OP_breg7 0x77 -#define DW_OP_breg8 0x78 -#define DW_OP_breg9 0x79 -#define DW_OP_breg10 0x7a -#define DW_OP_breg11 0x7b -#define DW_OP_breg12 0x7c -#define DW_OP_breg13 0x7d -#define DW_OP_breg14 0x7e -#define DW_OP_breg15 0x7f -#define DW_OP_breg16 0x80 -#define DW_OP_breg17 0x81 -#define DW_OP_breg18 0x82 -#define DW_OP_breg19 0x83 -#define DW_OP_breg20 0x84 -#define DW_OP_breg21 0x85 -#define DW_OP_breg22 0x86 -#define DW_OP_breg23 0x87 -#define DW_OP_breg24 0x88 -#define DW_OP_breg25 0x89 -#define DW_OP_breg26 0x8a -#define DW_OP_breg27 0x8b -#define DW_OP_breg28 0x8c -#define DW_OP_breg29 0x8d -#define DW_OP_breg30 0x8e -#define DW_OP_breg31 0x8f -#define DW_OP_regx 0x90 -#define DW_OP_fbreg 0x91 -#define DW_OP_bregx 0x92 -#define DW_OP_piece 0x93 -#define DW_OP_deref_size 0x94 -#define DW_OP_xderef_size 0x95 -#define DW_OP_nop 0x96 -#define DW_OP_push_object_address 0x97 -#define DW_OP_call2 0x98 -#define DW_OP_call4 0x99 -#define DW_OP_call_ref 0x9a -#define DW_OP_form_tls_address 0x9b -#define DW_OP_call_frame_cfa 0x9c -#define DW_OP_bit_piece 0x9d -#define DW_OP_lo_user 0xe0 -#define DW_OP_hi_user 0xff -#define DW_OP_GNU_push_tls_address 0xe0 -#define DW_OP_GNU_uninit 0xf0 -#define DW_OP_GNU_encoded_addr 0xf1 - -#define DW_EH_PE_native 0x00 -#define DW_EH_PE_uleb128 0x01 -#define DW_EH_PE_udata2 0x02 -#define DW_EH_PE_udata4 0x03 -#define DW_EH_PE_udata8 0x04 -#define DW_EH_PE_sleb128 0x09 -#define DW_EH_PE_sdata2 0x0a -#define DW_EH_PE_sdata4 0x0b -#define DW_EH_PE_sdata8 0x0c -#define DW_EH_PE_signed 0x08 -#define DW_EH_PE_abs 0x00 -#define DW_EH_PE_pcrel 0x10 -#define DW_EH_PE_textrel 0x20 -#define DW_EH_PE_datarel 0x30 -#define DW_EH_PE_funcrel 0x40 -#define DW_EH_PE_aligned 0x50 -#define DW_EH_PE_indirect 0x80 -#define DW_EH_PE_omit 0xff - -struct dwarf_eh_bases -{ - void *tbase; - void *dbase; - void *func; -}; - -struct dwarf_cie -{ - unsigned int length; - int id; - unsigned char version; - unsigned char augmentation[1]; -}; - -struct dwarf_fde -{ - unsigned int length; - unsigned int cie_offset; -}; - -extern const struct dwarf_fde *_Unwind_Find_FDE (void *, struct dwarf_eh_bases *); - -static unsigned char dwarf_get_u1( const unsigned char **p ) -{ - return *(*p)++; -} - -static unsigned short dwarf_get_u2( const unsigned char **p ) -{ - unsigned int ret = (*p)[0] | ((*p)[1] << 8); - (*p) += 2; - return ret; -} - -static unsigned int dwarf_get_u4( const unsigned char **p ) -{ - unsigned int ret = (*p)[0] | ((*p)[1] << 8) | ((*p)[2] << 16) | ((*p)[3] << 24); - (*p) += 4; - return ret; -} - -static ULONG64 dwarf_get_u8( const unsigned char **p ) -{ - ULONG64 low = dwarf_get_u4( p ); - ULONG64 high = dwarf_get_u4( p ); - return low | (high << 32); -} - -static ULONG_PTR dwarf_get_uleb128( const unsigned char **p ) -{ - ULONG_PTR ret = 0; - unsigned int shift = 0; - unsigned char byte; - - do - { - byte = **p; - ret |= (ULONG_PTR)(byte & 0x7f) << shift; - shift += 7; - (*p)++; - } while (byte & 0x80); - return ret; -} - -static LONG_PTR dwarf_get_sleb128( const unsigned char **p ) -{ - ULONG_PTR ret = 0; - unsigned int shift = 0; - unsigned char byte; - - do - { - byte = **p; - ret |= (ULONG_PTR)(byte & 0x7f) << shift; - shift += 7; - (*p)++; - } while (byte & 0x80); - - if ((shift < 8 * sizeof(ret)) && (byte & 0x40)) ret |= -((ULONG_PTR)1 << shift); - return ret; -} - -static ULONG_PTR dwarf_get_ptr( const unsigned char **p, unsigned char encoding, const struct dwarf_eh_bases *bases ) -{ - ULONG_PTR base; - - if (encoding == DW_EH_PE_omit) return 0; - - switch (encoding & 0x70) - { - case DW_EH_PE_abs: - base = 0; - break; - case DW_EH_PE_pcrel: - base = (ULONG_PTR)*p; - break; - case DW_EH_PE_textrel: - base = (ULONG_PTR)bases->tbase; - break; - case DW_EH_PE_datarel: - base = (ULONG_PTR)bases->dbase; - break; - case DW_EH_PE_funcrel: - base = (ULONG_PTR)bases->func; - break; - case DW_EH_PE_aligned: - base = ((ULONG_PTR)*p + 7) & ~7ul; - break; - default: - FIXME( "unsupported encoding %02x\n", encoding ); - return 0; - } - - switch (encoding & 0x0f) - { - case DW_EH_PE_native: base += dwarf_get_u8( p ); break; - case DW_EH_PE_uleb128: base += dwarf_get_uleb128( p ); break; - case DW_EH_PE_udata2: base += dwarf_get_u2( p ); break; - case DW_EH_PE_udata4: base += dwarf_get_u4( p ); break; - case DW_EH_PE_udata8: base += dwarf_get_u8( p ); break; - case DW_EH_PE_sleb128: base += dwarf_get_sleb128( p ); break; - case DW_EH_PE_sdata2: base += (signed short)dwarf_get_u2( p ); break; - case DW_EH_PE_sdata4: base += (signed int)dwarf_get_u4( p ); break; - case DW_EH_PE_sdata8: base += (LONG64)dwarf_get_u8( p ); break; - default: - FIXME( "unsupported encoding %02x\n", encoding ); - return 0; - } - if (encoding & DW_EH_PE_indirect) base = *(ULONG_PTR *)base; - return base; -} - -enum reg_rule -{ - RULE_UNSET, /* not set at all */ - RULE_UNDEFINED, /* undefined value */ - RULE_SAME, /* same value as previous frame */ - RULE_CFA_OFFSET, /* stored at cfa offset */ - RULE_OTHER_REG, /* stored in other register */ - RULE_EXPRESSION, /* address specified by expression */ - RULE_VAL_EXPRESSION /* value specified by expression */ -}; - -#define NB_FRAME_REGS 41 -#define MAX_SAVED_STATES 16 - -struct frame_state -{ - ULONG_PTR cfa_offset; - unsigned char cfa_reg; - enum reg_rule cfa_rule; - enum reg_rule rules[NB_FRAME_REGS]; - ULONG64 regs[NB_FRAME_REGS]; -}; - -struct frame_info -{ - ULONG_PTR ip; - ULONG_PTR code_align; - LONG_PTR data_align; - unsigned char retaddr_reg; - unsigned char fde_encoding; - unsigned char signal_frame; - unsigned char state_sp; - struct frame_state state; - struct frame_state *state_stack; -}; - -static const char *dwarf_reg_names[NB_FRAME_REGS] = -{ -/* 0-7 */ "%rax", "%rdx", "%rcx", "%rbx", "%rsi", "%rdi", "%rbp", "%rsp", -/* 8-16 */ "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "%rip", -/* 17-24 */ "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", -/* 25-32 */ "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", -/* 33-40 */ "%st0", "%st1", "%st2", "%st3", "%st4", "%st5", "%st6", "%st7" -}; - -static BOOL valid_reg( ULONG_PTR reg ) -{ - if (reg >= NB_FRAME_REGS) FIXME( "unsupported reg %lx\n", reg ); - return (reg < NB_FRAME_REGS); -} - -static void execute_cfa_instructions( const unsigned char *ptr, const unsigned char *end, - ULONG_PTR last_ip, struct frame_info *info, - const struct dwarf_eh_bases *bases ) -{ - while (ptr < end && info->ip < last_ip + info->signal_frame) - { - const unsigned char op = *ptr++; - - if (op & 0xc0) - { - switch (op & 0xc0) - { - case DW_CFA_advance_loc: - { - ULONG_PTR offset = (op & 0x3f) * info->code_align; - TRACE( "%lx: DW_CFA_advance_loc %lu\n", info->ip, offset ); - info->ip += offset; - break; - } - case DW_CFA_offset: - { - ULONG_PTR reg = op & 0x3f; - LONG_PTR offset = dwarf_get_uleb128( &ptr ) * info->data_align; - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_offset %s, %ld\n", info->ip, dwarf_reg_names[reg], offset ); - info->state.regs[reg] = offset; - info->state.rules[reg] = RULE_CFA_OFFSET; - break; - } - case DW_CFA_restore: - { - ULONG_PTR reg = op & 0x3f; - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_restore %s\n", info->ip, dwarf_reg_names[reg] ); - info->state.rules[reg] = RULE_UNSET; - break; - } - } - } - else switch (op) - { - case DW_CFA_nop: - break; - case DW_CFA_set_loc: - { - ULONG_PTR loc = dwarf_get_ptr( &ptr, info->fde_encoding, bases ); - TRACE( "%lx: DW_CFA_set_loc %lx\n", info->ip, loc ); - info->ip = loc; - break; - } - case DW_CFA_advance_loc1: - { - ULONG_PTR offset = *ptr++ * info->code_align; - TRACE( "%lx: DW_CFA_advance_loc1 %lu\n", info->ip, offset ); - info->ip += offset; - break; - } - case DW_CFA_advance_loc2: - { - ULONG_PTR offset = dwarf_get_u2( &ptr ) * info->code_align; - TRACE( "%lx: DW_CFA_advance_loc2 %lu\n", info->ip, offset ); - info->ip += offset; - break; - } - case DW_CFA_advance_loc4: - { - ULONG_PTR offset = dwarf_get_u4( &ptr ) * info->code_align; - TRACE( "%lx: DW_CFA_advance_loc4 %lu\n", info->ip, offset ); - info->ip += offset; - break; - } - case DW_CFA_offset_extended: - case DW_CFA_offset_extended_sf: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - LONG_PTR offset = (op == DW_CFA_offset_extended) ? dwarf_get_uleb128( &ptr ) * info->data_align - : dwarf_get_sleb128( &ptr ) * info->data_align; - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_offset_extended %s, %ld\n", info->ip, dwarf_reg_names[reg], offset ); - info->state.regs[reg] = offset; - info->state.rules[reg] = RULE_CFA_OFFSET; - break; - } - case DW_CFA_restore_extended: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_restore_extended %s\n", info->ip, dwarf_reg_names[reg] ); - info->state.rules[reg] = RULE_UNSET; - break; - } - case DW_CFA_undefined: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_undefined %s\n", info->ip, dwarf_reg_names[reg] ); - info->state.rules[reg] = RULE_UNDEFINED; - break; - } - case DW_CFA_same_value: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_same_value %s\n", info->ip, dwarf_reg_names[reg] ); - info->state.regs[reg] = reg; - info->state.rules[reg] = RULE_SAME; - break; - } - case DW_CFA_register: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - ULONG_PTR reg2 = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg ) || !valid_reg( reg2 )) break; - TRACE( "%lx: DW_CFA_register %s == %s\n", info->ip, dwarf_reg_names[reg], dwarf_reg_names[reg2] ); - info->state.regs[reg] = reg2; - info->state.rules[reg] = RULE_OTHER_REG; - break; - } - case DW_CFA_remember_state: - TRACE( "%lx: DW_CFA_remember_state\n", info->ip ); - if (info->state_sp >= MAX_SAVED_STATES) - FIXME( "%lx: DW_CFA_remember_state too many nested saves\n", info->ip ); - else - info->state_stack[info->state_sp++] = info->state; - break; - case DW_CFA_restore_state: - TRACE( "%lx: DW_CFA_restore_state\n", info->ip ); - if (!info->state_sp) - FIXME( "%lx: DW_CFA_restore_state without corresponding save\n", info->ip ); - else - info->state = info->state_stack[--info->state_sp]; - break; - case DW_CFA_def_cfa: - case DW_CFA_def_cfa_sf: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - ULONG_PTR offset = (op == DW_CFA_def_cfa) ? dwarf_get_uleb128( &ptr ) - : dwarf_get_sleb128( &ptr ) * info->data_align; - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_def_cfa %s, %lu\n", info->ip, dwarf_reg_names[reg], offset ); - info->state.cfa_reg = reg; - info->state.cfa_offset = offset; - info->state.cfa_rule = RULE_CFA_OFFSET; - break; - } - case DW_CFA_def_cfa_register: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_def_cfa_register %s\n", info->ip, dwarf_reg_names[reg] ); - info->state.cfa_reg = reg; - info->state.cfa_rule = RULE_CFA_OFFSET; - break; - } - case DW_CFA_def_cfa_offset: - case DW_CFA_def_cfa_offset_sf: - { - ULONG_PTR offset = (op == DW_CFA_def_cfa_offset) ? dwarf_get_uleb128( &ptr ) - : dwarf_get_sleb128( &ptr ) * info->data_align; - TRACE( "%lx: DW_CFA_def_cfa_offset %lu\n", info->ip, offset ); - info->state.cfa_offset = offset; - info->state.cfa_rule = RULE_CFA_OFFSET; - break; - } - case DW_CFA_def_cfa_expression: - { - ULONG_PTR expr = (ULONG_PTR)ptr; - ULONG_PTR len = dwarf_get_uleb128( &ptr ); - TRACE( "%lx: DW_CFA_def_cfa_expression %lx-%lx\n", info->ip, expr, expr+len ); - info->state.cfa_offset = expr; - info->state.cfa_rule = RULE_VAL_EXPRESSION; - ptr += len; - break; - } - case DW_CFA_expression: - case DW_CFA_val_expression: - { - ULONG_PTR reg = dwarf_get_uleb128( &ptr ); - ULONG_PTR expr = (ULONG_PTR)ptr; - ULONG_PTR len = dwarf_get_uleb128( &ptr ); - if (!valid_reg( reg )) break; - TRACE( "%lx: DW_CFA_%sexpression %s %lx-%lx\n", - info->ip, (op == DW_CFA_expression) ? "" : "val_", dwarf_reg_names[reg], expr, expr+len ); - info->state.regs[reg] = expr; - info->state.rules[reg] = (op == DW_CFA_expression) ? RULE_EXPRESSION : RULE_VAL_EXPRESSION; - ptr += len; - break; - } - default: - FIXME( "%lx: unknown CFA opcode %02x\n", info->ip, op ); - break; - } - } -} - -/* retrieve a context register from its dwarf number */ -static void *get_context_reg( CONTEXT *context, ULONG_PTR dw_reg ) -{ - switch (dw_reg) - { - case 0: return &context->Rax; - case 1: return &context->Rdx; - case 2: return &context->Rcx; - case 3: return &context->Rbx; - case 4: return &context->Rsi; - case 5: return &context->Rdi; - case 6: return &context->Rbp; - case 7: return &context->Rsp; - case 8: return &context->R8; - case 9: return &context->R9; - case 10: return &context->R10; - case 11: return &context->R11; - case 12: return &context->R12; - case 13: return &context->R13; - case 14: return &context->R14; - case 15: return &context->R15; - case 16: return &context->Rip; - case 17: return &context->u.s.Xmm0; - case 18: return &context->u.s.Xmm1; - case 19: return &context->u.s.Xmm2; - case 20: return &context->u.s.Xmm3; - case 21: return &context->u.s.Xmm4; - case 22: return &context->u.s.Xmm5; - case 23: return &context->u.s.Xmm6; - case 24: return &context->u.s.Xmm7; - case 25: return &context->u.s.Xmm8; - case 26: return &context->u.s.Xmm9; - case 27: return &context->u.s.Xmm10; - case 28: return &context->u.s.Xmm11; - case 29: return &context->u.s.Xmm12; - case 30: return &context->u.s.Xmm13; - case 31: return &context->u.s.Xmm14; - case 32: return &context->u.s.Xmm15; - case 33: return &context->u.s.Legacy[0]; - case 34: return &context->u.s.Legacy[1]; - case 35: return &context->u.s.Legacy[2]; - case 36: return &context->u.s.Legacy[3]; - case 37: return &context->u.s.Legacy[4]; - case 38: return &context->u.s.Legacy[5]; - case 39: return &context->u.s.Legacy[6]; - case 40: return &context->u.s.Legacy[7]; - default: return NULL; - } -} - -/* set a context register from its dwarf number */ -static void set_context_reg( CONTEXT *context, ULONG_PTR dw_reg, void *val ) -{ - switch (dw_reg) - { - case 0: context->Rax = *(ULONG64 *)val; break; - case 1: context->Rdx = *(ULONG64 *)val; break; - case 2: context->Rcx = *(ULONG64 *)val; break; - case 3: context->Rbx = *(ULONG64 *)val; break; - case 4: context->Rsi = *(ULONG64 *)val; break; - case 5: context->Rdi = *(ULONG64 *)val; break; - case 6: context->Rbp = *(ULONG64 *)val; break; - case 7: context->Rsp = *(ULONG64 *)val; break; - case 8: context->R8 = *(ULONG64 *)val; break; - case 9: context->R9 = *(ULONG64 *)val; break; - case 10: context->R10 = *(ULONG64 *)val; break; - case 11: context->R11 = *(ULONG64 *)val; break; - case 12: context->R12 = *(ULONG64 *)val; break; - case 13: context->R13 = *(ULONG64 *)val; break; - case 14: context->R14 = *(ULONG64 *)val; break; - case 15: context->R15 = *(ULONG64 *)val; break; - case 16: context->Rip = *(ULONG64 *)val; break; - case 17: memcpy( &context->u.s.Xmm0, val, sizeof(M128A) ); break; - case 18: memcpy( &context->u.s.Xmm1, val, sizeof(M128A) ); break; - case 19: memcpy( &context->u.s.Xmm2, val, sizeof(M128A) ); break; - case 20: memcpy( &context->u.s.Xmm3, val, sizeof(M128A) ); break; - case 21: memcpy( &context->u.s.Xmm4, val, sizeof(M128A) ); break; - case 22: memcpy( &context->u.s.Xmm5, val, sizeof(M128A) ); break; - case 23: memcpy( &context->u.s.Xmm6, val, sizeof(M128A) ); break; - case 24: memcpy( &context->u.s.Xmm7, val, sizeof(M128A) ); break; - case 25: memcpy( &context->u.s.Xmm8, val, sizeof(M128A) ); break; - case 26: memcpy( &context->u.s.Xmm9, val, sizeof(M128A) ); break; - case 27: memcpy( &context->u.s.Xmm10, val, sizeof(M128A) ); break; - case 28: memcpy( &context->u.s.Xmm11, val, sizeof(M128A) ); break; - case 29: memcpy( &context->u.s.Xmm12, val, sizeof(M128A) ); break; - case 30: memcpy( &context->u.s.Xmm13, val, sizeof(M128A) ); break; - case 31: memcpy( &context->u.s.Xmm14, val, sizeof(M128A) ); break; - case 32: memcpy( &context->u.s.Xmm15, val, sizeof(M128A) ); break; - case 33: memcpy( &context->u.s.Legacy[0], val, sizeof(M128A) ); break; - case 34: memcpy( &context->u.s.Legacy[1], val, sizeof(M128A) ); break; - case 35: memcpy( &context->u.s.Legacy[2], val, sizeof(M128A) ); break; - case 36: memcpy( &context->u.s.Legacy[3], val, sizeof(M128A) ); break; - case 37: memcpy( &context->u.s.Legacy[4], val, sizeof(M128A) ); break; - case 38: memcpy( &context->u.s.Legacy[5], val, sizeof(M128A) ); break; - case 39: memcpy( &context->u.s.Legacy[6], val, sizeof(M128A) ); break; - case 40: memcpy( &context->u.s.Legacy[7], val, sizeof(M128A) ); break; - } -} - -static ULONG_PTR eval_expression( const unsigned char *p, CONTEXT *context, - const struct dwarf_eh_bases *bases ) -{ - ULONG_PTR reg, tmp, stack[64]; - int sp = -1; - ULONG_PTR len = dwarf_get_uleb128(&p); - const unsigned char *end = p + len; - - while (p < end) - { - unsigned char opcode = dwarf_get_u1(&p); - - if (opcode >= DW_OP_lit0 && opcode <= DW_OP_lit31) - stack[++sp] = opcode - DW_OP_lit0; - else if (opcode >= DW_OP_reg0 && opcode <= DW_OP_reg31) - stack[++sp] = *(ULONG_PTR *)get_context_reg( context, opcode - DW_OP_reg0 ); - else if (opcode >= DW_OP_breg0 && opcode <= DW_OP_breg31) - stack[++sp] = *(ULONG_PTR *)get_context_reg( context, opcode - DW_OP_breg0 ) + dwarf_get_sleb128(&p); - else switch (opcode) - { - case DW_OP_nop: break; - case DW_OP_addr: stack[++sp] = dwarf_get_u8(&p); break; - case DW_OP_const1u: stack[++sp] = dwarf_get_u1(&p); break; - case DW_OP_const1s: stack[++sp] = (signed char)dwarf_get_u1(&p); break; - case DW_OP_const2u: stack[++sp] = dwarf_get_u2(&p); break; - case DW_OP_const2s: stack[++sp] = (short)dwarf_get_u2(&p); break; - case DW_OP_const4u: stack[++sp] = dwarf_get_u4(&p); break; - case DW_OP_const4s: stack[++sp] = (signed int)dwarf_get_u4(&p); break; - case DW_OP_const8u: stack[++sp] = dwarf_get_u8(&p); break; - case DW_OP_const8s: stack[++sp] = (LONG_PTR)dwarf_get_u8(&p); break; - case DW_OP_constu: stack[++sp] = dwarf_get_uleb128(&p); break; - case DW_OP_consts: stack[++sp] = dwarf_get_sleb128(&p); break; - case DW_OP_deref: stack[sp] = *(ULONG_PTR *)stack[sp]; break; - case DW_OP_dup: stack[sp + 1] = stack[sp]; sp++; break; - case DW_OP_drop: sp--; break; - case DW_OP_over: stack[sp + 1] = stack[sp - 1]; sp++; break; - case DW_OP_pick: stack[sp + 1] = stack[sp - dwarf_get_u1(&p)]; sp++; break; - case DW_OP_swap: tmp = stack[sp]; stack[sp] = stack[sp-1]; stack[sp-1] = tmp; break; - case DW_OP_rot: tmp = stack[sp]; stack[sp] = stack[sp-1]; stack[sp-1] = stack[sp-2]; stack[sp-2] = tmp; break; - case DW_OP_abs: stack[sp] = labs(stack[sp]); break; - case DW_OP_neg: stack[sp] = -stack[sp]; break; - case DW_OP_not: stack[sp] = ~stack[sp]; break; - case DW_OP_and: stack[sp-1] &= stack[sp]; sp--; break; - case DW_OP_or: stack[sp-1] |= stack[sp]; sp--; break; - case DW_OP_minus: stack[sp-1] -= stack[sp]; sp--; break; - case DW_OP_mul: stack[sp-1] *= stack[sp]; sp--; break; - case DW_OP_plus: stack[sp-1] += stack[sp]; sp--; break; - case DW_OP_xor: stack[sp-1] ^= stack[sp]; sp--; break; - case DW_OP_shl: stack[sp-1] <<= stack[sp]; sp--; break; - case DW_OP_shr: stack[sp-1] >>= stack[sp]; sp--; break; - case DW_OP_plus_uconst: stack[sp] += dwarf_get_uleb128(&p); break; - case DW_OP_shra: stack[sp-1] = (LONG_PTR)stack[sp-1] / (1 << stack[sp]); sp--; break; - case DW_OP_div: stack[sp-1] = (LONG_PTR)stack[sp-1] / (LONG_PTR)stack[sp]; sp--; break; - case DW_OP_mod: stack[sp-1] = (LONG_PTR)stack[sp-1] % (LONG_PTR)stack[sp]; sp--; break; - case DW_OP_ge: stack[sp-1] = ((LONG_PTR)stack[sp-1] >= (LONG_PTR)stack[sp]); sp--; break; - case DW_OP_gt: stack[sp-1] = ((LONG_PTR)stack[sp-1] > (LONG_PTR)stack[sp]); sp--; break; - case DW_OP_le: stack[sp-1] = ((LONG_PTR)stack[sp-1] <= (LONG_PTR)stack[sp]); sp--; break; - case DW_OP_lt: stack[sp-1] = ((LONG_PTR)stack[sp-1] < (LONG_PTR)stack[sp]); sp--; break; - case DW_OP_eq: stack[sp-1] = (stack[sp-1] == stack[sp]); sp--; break; - case DW_OP_ne: stack[sp-1] = (stack[sp-1] != stack[sp]); sp--; break; - case DW_OP_skip: tmp = (short)dwarf_get_u2(&p); p += tmp; break; - case DW_OP_bra: tmp = (short)dwarf_get_u2(&p); if (!stack[sp--]) p += tmp; break; - case DW_OP_GNU_encoded_addr: tmp = *p++; stack[++sp] = dwarf_get_ptr( &p, tmp, bases ); break; - case DW_OP_regx: stack[++sp] = *(ULONG_PTR *)get_context_reg( context, dwarf_get_uleb128(&p) ); break; - case DW_OP_bregx: - reg = dwarf_get_uleb128(&p); - tmp = dwarf_get_sleb128(&p); - stack[++sp] = *(ULONG_PTR *)get_context_reg( context, reg ) + tmp; - break; - case DW_OP_deref_size: - switch (*p++) - { - case 1: stack[sp] = *(unsigned char *)stack[sp]; break; - case 2: stack[sp] = *(unsigned short *)stack[sp]; break; - case 4: stack[sp] = *(unsigned int *)stack[sp]; break; - case 8: stack[sp] = *(ULONG_PTR *)stack[sp]; break; - } - break; - default: - FIXME( "unhandled opcode %02x\n", opcode ); - } - } - return stack[sp]; -} - -/* apply the computed frame info to the actual context */ -static void apply_frame_state( CONTEXT *context, struct frame_state *state, - const struct dwarf_eh_bases *bases ) -{ - unsigned int i; - ULONG_PTR cfa, value; - CONTEXT new_context = *context; - - switch (state->cfa_rule) - { - case RULE_EXPRESSION: - cfa = *(ULONG_PTR *)eval_expression( (const unsigned char *)state->cfa_offset, context, bases ); - break; - case RULE_VAL_EXPRESSION: - cfa = eval_expression( (const unsigned char *)state->cfa_offset, context, bases ); - break; - default: - cfa = *(ULONG_PTR *)get_context_reg( context, state->cfa_reg ) + state->cfa_offset; - break; - } - if (!cfa) return; - - for (i = 0; i < NB_FRAME_REGS; i++) - { - switch (state->rules[i]) - { - case RULE_UNSET: - case RULE_UNDEFINED: - case RULE_SAME: - break; - case RULE_CFA_OFFSET: - set_context_reg( &new_context, i, (char *)cfa + state->regs[i] ); - break; - case RULE_OTHER_REG: - set_context_reg( &new_context, i, get_context_reg( context, state->regs[i] )); - break; - case RULE_EXPRESSION: - value = eval_expression( (const unsigned char *)state->regs[i], context, bases ); - set_context_reg( &new_context, i, (void *)value ); - break; - case RULE_VAL_EXPRESSION: - value = eval_expression( (const unsigned char *)state->regs[i], context, bases ); - set_context_reg( &new_context, i, &value ); - break; - } - } - new_context.Rsp = cfa; - *context = new_context; -} -

/*********************************************************************** * dwarf_virtual_unwind

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Martin Storsjö

10:03 a.m.

New subject: [PATCH 2/5] ntdll: Add support for aarch64 in the dwarf implementation

From: Martin Storsjö martin@martin.st

This is essentially about mapping dwarf register numbers to aarch64 registers, and for updating the right CONTEXT variable with the CFA.

Signed-off-by: Martin Storsjö martin@martin.st --- dlls/ntdll/unix/dwarf.h | 164 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+)

diff --git a/dlls/ntdll/unix/dwarf.h b/dlls/ntdll/unix/dwarf.h index 33cc8315bd6..cae7d6288ee 100644 --- a/dlls/ntdll/unix/dwarf.h +++ b/dlls/ntdll/unix/dwarf.h @@ -377,7 +377,13 @@ enum reg_rule RULE_VAL_EXPRESSION /* value specified by expression */ };

+#ifdef __x86_64__ #define NB_FRAME_REGS 41 +#elif defined(__aarch64__) +#define NB_FRAME_REGS 96 +#else +#error Unsupported architecture +#endif #define MAX_SAVED_STATES 16

struct frame_state @@ -404,11 +410,26 @@ struct frame_info

static const char *dwarf_reg_names[NB_FRAME_REGS] = { +#ifdef __x86_64__ /* 0-7 */ "%rax", "%rdx", "%rcx", "%rbx", "%rsi", "%rdi", "%rbp", "%rsp", /* 8-16 */ "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15", "%rip", /* 17-24 */ "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7", /* 25-32 */ "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", "%xmm15", /* 33-40 */ "%st0", "%st1", "%st2", "%st3", "%st4", "%st5", "%st6", "%st7" +#elif defined(__aarch64__) +/* 0-7 */ "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", +/* 8-15 */ "x8", "x9", "x10", "x11", "x12", "x13", "x14", "x15", +/* 16-23 */ "x16", "x17", "x18", "x19", "x20", "x21", "x22", "x23", +/* 24-31 */ "x24", "x25", "x26", "x27", "x28", "x29", "x30", "sp", +/* 32-39 */ "pc", NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 40-47 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 48-55 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 56-63 */ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, +/* 64-71 */ "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", +/* 72-79 */ "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", +/* 80-87 */ "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", +/* 88-95 */ "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31", +#endif };

static BOOL valid_reg( ULONG_PTR reg ) @@ -617,6 +638,7 @@ static void *get_context_reg( CONTEXT *context, ULONG_PTR dw_reg ) { switch (dw_reg) { +#ifdef __x86_64__ case 0: return &context->Rax; case 1: return &context->Rdx; case 2: return &context->Rcx; @@ -658,6 +680,74 @@ static void *get_context_reg( CONTEXT *context, ULONG_PTR dw_reg ) case 38: return &context->u.s.Legacy[5]; case 39: return &context->u.s.Legacy[6]; case 40: return &context->u.s.Legacy[7]; +#elif defined(__aarch64__) + case 0: return &context->u.s.X0; + case 1: return &context->u.s.X1; + case 2: return &context->u.s.X2; + case 3: return &context->u.s.X3; + case 4: return &context->u.s.X4; + case 5: return &context->u.s.X5; + case 6: return &context->u.s.X6; + case 7: return &context->u.s.X7; + case 8: return &context->u.s.X8; + case 9: return &context->u.s.X9; + case 10: return &context->u.s.X10; + case 11: return &context->u.s.X11; + case 12: return &context->u.s.X12; + case 13: return &context->u.s.X13; + case 14: return &context->u.s.X14; + case 15: return &context->u.s.X15; + case 16: return &context->u.s.X16; + case 17: return &context->u.s.X17; + case 18: return &context->u.s.X18; + case 19: return &context->u.s.X19; + case 20: return &context->u.s.X20; + case 21: return &context->u.s.X21; + case 22: return &context->u.s.X22; + case 23: return &context->u.s.X23; + case 24: return &context->u.s.X24; + case 25: return &context->u.s.X25; + case 26: return &context->u.s.X26; + case 27: return &context->u.s.X27; + case 28: return &context->u.s.X28; + case 29: return &context->u.s.Fp; + case 30: return &context->u.s.Lr; + case 31: return &context->Sp; + case 32: return &context->Pc; + case 64: + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + return &context->V[dw_reg - 64]; +#endif default: return NULL; } } @@ -667,6 +757,7 @@ static void set_context_reg( CONTEXT *context, ULONG_PTR dw_reg, void *val ) { switch (dw_reg) { +#ifdef __x86_64__ case 0: context->Rax = *(ULONG64 *)val; break; case 1: context->Rdx = *(ULONG64 *)val; break; case 2: context->Rcx = *(ULONG64 *)val; break; @@ -708,6 +799,75 @@ static void set_context_reg( CONTEXT *context, ULONG_PTR dw_reg, void *val ) case 38: memcpy( &context->u.s.Legacy[5], val, sizeof(M128A) ); break; case 39: memcpy( &context->u.s.Legacy[6], val, sizeof(M128A) ); break; case 40: memcpy( &context->u.s.Legacy[7], val, sizeof(M128A) ); break; +#elif defined(__aarch64__) + case 0: context->u.s.X0 = *(DWORD64 *)val; break; + case 1: context->u.s.X1 = *(DWORD64 *)val; break; + case 2: context->u.s.X2 = *(DWORD64 *)val; break; + case 3: context->u.s.X3 = *(DWORD64 *)val; break; + case 4: context->u.s.X4 = *(DWORD64 *)val; break; + case 5: context->u.s.X5 = *(DWORD64 *)val; break; + case 6: context->u.s.X6 = *(DWORD64 *)val; break; + case 7: context->u.s.X7 = *(DWORD64 *)val; break; + case 8: context->u.s.X8 = *(DWORD64 *)val; break; + case 9: context->u.s.X9 = *(DWORD64 *)val; break; + case 10: context->u.s.X10 = *(DWORD64 *)val; break; + case 11: context->u.s.X11 = *(DWORD64 *)val; break; + case 12: context->u.s.X12 = *(DWORD64 *)val; break; + case 13: context->u.s.X13 = *(DWORD64 *)val; break; + case 14: context->u.s.X14 = *(DWORD64 *)val; break; + case 15: context->u.s.X15 = *(DWORD64 *)val; break; + case 16: context->u.s.X16 = *(DWORD64 *)val; break; + case 17: context->u.s.X17 = *(DWORD64 *)val; break; + case 18: context->u.s.X18 = *(DWORD64 *)val; break; + case 19: context->u.s.X19 = *(DWORD64 *)val; break; + case 20: context->u.s.X20 = *(DWORD64 *)val; break; + case 21: context->u.s.X21 = *(DWORD64 *)val; break; + case 22: context->u.s.X22 = *(DWORD64 *)val; break; + case 23: context->u.s.X23 = *(DWORD64 *)val; break; + case 24: context->u.s.X24 = *(DWORD64 *)val; break; + case 25: context->u.s.X25 = *(DWORD64 *)val; break; + case 26: context->u.s.X26 = *(DWORD64 *)val; break; + case 27: context->u.s.X27 = *(DWORD64 *)val; break; + case 28: context->u.s.X28 = *(DWORD64 *)val; break; + case 29: context->u.s.Fp = *(DWORD64 *)val; break; + case 30: context->u.s.Lr = *(DWORD64 *)val; break; + case 31: context->Sp = *(DWORD64 *)val; break; + case 32: context->Pc = *(DWORD64 *)val; break; + case 64: + case 65: + case 66: + case 67: + case 68: + case 69: + case 70: + case 71: + case 72: + case 73: + case 74: + case 75: + case 76: + case 77: + case 78: + case 79: + case 80: + case 81: + case 82: + case 83: + case 84: + case 85: + case 86: + case 87: + case 88: + case 89: + case 90: + case 91: + case 92: + case 93: + case 94: + case 95: + memcpy( &context->V[dw_reg - 64], val, sizeof(ARM64_NT_NEON128) ); + break; +#endif } }

@@ -842,7 +1002,11 @@ static void apply_frame_state( CONTEXT *context, struct frame_state *state, break; } } +#ifdef __x86_64__ new_context.Rsp = cfa; +#elif defined(__aarch64__) + new_context.Sp = cfa; +#endif *context = new_context; }

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Martin Storsjö

10:03 a.m.

New subject: [PATCH 3/5] ntdll: Use the local dwarf implementation on arm64

From: Martin Storsjö martin@martin.st

This makes unwinding work if libunwind is unavailable.

The dwarf_virtual_unwind function is modelled heavily on the x86_64 version of it. (Going forward, if there are changes to either of them, one should probably look at whether those changes should be mirrored to the other one too.)

Signed-off-by: Martin Storsjö martin@martin.st --- dlls/ntdll/unix/signal_arm64.c | 171 +++++++++++++++++++++++++++++++-- 1 file changed, 162 insertions(+), 9 deletions(-)

diff --git a/dlls/ntdll/unix/signal_arm64.c b/dlls/ntdll/unix/signal_arm64.c index 4e552e0f10a..19d08e2270a 100644 --- a/dlls/ntdll/unix/signal_arm64.c +++ b/dlls/ntdll/unix/signal_arm64.c @@ -68,6 +68,8 @@

WINE_DEFAULT_DEBUG_CHANNEL(seh);

+#include "dwarf.h" + /*********************************************************************** * signal context platform-specific definitions */ @@ -172,14 +174,146 @@ static BOOL is_inside_syscall( ucontext_t *sigcontext ) extern void raise_func_trampoline( EXCEPTION_RECORD *rec, CONTEXT *context, void *dispatcher );

/*********************************************************************** - * unwind_builtin_dll + * dwarf_virtual_unwind * * Equivalent of RtlVirtualUnwind for builtin modules. */ -NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CONTEXT *context ) +static NTSTATUS dwarf_virtual_unwind( ULONG64 ip, ULONG64 *frame, CONTEXT *context, + const struct dwarf_fde *fde, const struct dwarf_eh_bases *bases, + PEXCEPTION_ROUTINE *handler, void **handler_data ) { + const struct dwarf_cie *cie; + const unsigned char *ptr, *augmentation, *end; + ULONG_PTR len, code_end; + struct frame_info info; + struct frame_state state_stack[MAX_SAVED_STATES]; + int aug_z_format = 0; + unsigned char lsda_encoding = DW_EH_PE_omit; + + memset( &info, 0, sizeof(info) ); + info.state_stack = state_stack; + info.ip = (ULONG_PTR)bases->func; + *handler = NULL; + + cie = (const struct dwarf_cie *)((const char *)&fde->cie_offset - fde->cie_offset); + + /* parse the CIE first */ + + if (cie->version != 1 && cie->version != 3) + { + FIXME( "unknown CIE version %u at %p\n", cie->version, cie ); + return STATUS_INVALID_DISPOSITION; + } + ptr = cie->augmentation + strlen((const char *)cie->augmentation) + 1; + + info.code_align = dwarf_get_uleb128( &ptr ); + info.data_align = dwarf_get_sleb128( &ptr ); + if (cie->version == 1) + info.retaddr_reg = *ptr++; + else + info.retaddr_reg = dwarf_get_uleb128( &ptr ); + info.state.cfa_rule = RULE_CFA_OFFSET; + + TRACE( "function %lx base %p cie %p len %x id %x version %x aug '%s' code_align %lu data_align %ld retaddr %s\n", + ip, bases->func, cie, cie->length, cie->id, cie->version, cie->augmentation, + info.code_align, info.data_align, dwarf_reg_names[info.retaddr_reg] ); + + end = NULL; + for (augmentation = cie->augmentation; *augmentation; augmentation++) + { + switch (*augmentation) + { + case 'z': + len = dwarf_get_uleb128( &ptr ); + end = ptr + len; + aug_z_format = 1; + continue; + case 'L': + lsda_encoding = *ptr++; + continue; + case 'P': + { + unsigned char encoding = *ptr++; + *handler = (void *)dwarf_get_ptr( &ptr, encoding, bases ); + continue; + } + case 'R': + info.fde_encoding = *ptr++; + continue; + case 'S': + info.signal_frame = 1; + continue; + } + FIXME( "unknown augmentation '%c'\n", *augmentation ); + if (!end) return STATUS_INVALID_DISPOSITION; /* cannot continue */ + break; + } + if (end) ptr = end; + + end = (const unsigned char *)(&cie->length + 1) + cie->length; + execute_cfa_instructions( ptr, end, ip, &info, bases ); + + ptr = (const unsigned char *)(fde + 1); + info.ip = dwarf_get_ptr( &ptr, info.fde_encoding, bases ); /* fde code start */ + code_end = info.ip + dwarf_get_ptr( &ptr, info.fde_encoding & 0x0f, bases ); /* fde code length */ + + if (aug_z_format) /* get length of augmentation data */ + { + len = dwarf_get_uleb128( &ptr ); + end = ptr + len; + } + else end = NULL; + + *handler_data = (void *)dwarf_get_ptr( &ptr, lsda_encoding, bases ); + if (end) ptr = end; + + end = (const unsigned char *)(&fde->length + 1) + fde->length; + TRACE( "fde %p len %x personality %p lsda %p code %lx-%lx\n", + fde, fde->length, *handler, *handler_data, info.ip, code_end ); + execute_cfa_instructions( ptr, end, ip, &info, bases ); + *frame = context->Sp; + apply_frame_state( context, &info.state, bases ); + context->ContextFlags |= CONTEXT_UNWOUND_TO_CALL; + /* Set Pc based on Lr; libunwind also does this as part of unw_step. */ + context->Pc = context->u.s.Lr; + + if (bases->func == (void *)raise_func_trampoline) { + /* raise_func_trampoline has a full CONTEXT stored on the stack; + * restore the original Lr value from there. The function we unwind + * to might be a leaf function that hasn't backed up its own original + * Lr value on the stack. + * We could also just restore the full context here without doing + * unw_step at all. */ + const CONTEXT *next_ctx = (const CONTEXT *) *frame; + context->u.s.Lr = next_ctx->u.s.Lr; + } + + TRACE( "next function pc=%016lx\n", context->Pc ); + TRACE(" x0=%016lx x1=%016lx x2=%016lx x3=%016lx\n", + context->u.s.X0, context->u.s.X1, context->u.s.X2, context->u.s.X3 ); + TRACE(" x4=%016lx x5=%016lx x6=%016lx x7=%016lx\n", + context->u.s.X4, context->u.s.X5, context->u.s.X6, context->u.s.X7 ); + TRACE(" x8=%016lx x9=%016lx x10=%016lx x11=%016lx\n", + context->u.s.X8, context->u.s.X9, context->u.s.X10, context->u.s.X11 ); + TRACE(" x12=%016lx x13=%016lx x14=%016lx x15=%016lx\n", + context->u.s.X12, context->u.s.X13, context->u.s.X14, context->u.s.X15 ); + TRACE(" x16=%016lx x17=%016lx x18=%016lx x19=%016lx\n", + context->u.s.X16, context->u.s.X17, context->u.s.X18, context->u.s.X19 ); + TRACE(" x20=%016lx x21=%016lx x22=%016lx x23=%016lx\n", + context->u.s.X20, context->u.s.X21, context->u.s.X22, context->u.s.X23 ); + TRACE(" x24=%016lx x25=%016lx x26=%016lx x27=%016lx\n", + context->u.s.X24, context->u.s.X25, context->u.s.X26, context->u.s.X27 ); + TRACE(" x28=%016lx fp=%016lx lr=%016lx sp=%016lx\n", + context->u.s.X28, context->u.s.Fp, context->u.s.Lr, context->Sp ); + + return STATUS_SUCCESS; +} + + #ifdef HAVE_LIBUNWIND - ULONG_PTR ip = context->Pc; +static NTSTATUS libunwind_virtual_unwind( ULONG_PTR ip, ULONG_PTR *frame, CONTEXT *context, + PEXCEPTION_ROUTINE *handler, void **handler_data ) +{ unw_context_t unw_context; unw_cursor_t cursor; unw_proc_info_t info; @@ -222,8 +356,8 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CON { TRACE( "no info found for %lx ip %lx-%lx, assuming leaf function\n", ip, info.start_ip, info.end_ip ); - dispatch->LanguageHandler = NULL; - dispatch->EstablisherFrame = context->Sp; + *handler = NULL; + *frame = context->Sp; context->Pc = context->u.s.Lr; context->ContextFlags |= CONTEXT_UNWOUND_TO_CALL; return STATUS_SUCCESS; @@ -240,9 +374,9 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CON return STATUS_INVALID_DISPOSITION; }

- dispatch->LanguageHandler = (void *)info.handler; - dispatch->HandlerData = (void *)info.lsda; - dispatch->EstablisherFrame = context->Sp; + *handler = (void *)info.handler; + *handler_data = (void *)info.lsda; + *frame = context->Sp; #ifdef __APPLE__ { int i; @@ -296,7 +430,7 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CON * Lr value on the stack. * We could also just restore the full context here without doing * unw_step at all. */ - const CONTEXT *next_ctx = (const CONTEXT *) dispatch->EstablisherFrame; + const CONTEXT *next_ctx = (const CONTEXT *) *frame; context->u.s.Lr = next_ctx->u.s.Lr; }

@@ -318,6 +452,25 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CON TRACE(" x28=%016lx fp=%016lx lr=%016lx sp=%016lx\n", context->u.s.X28, context->u.s.Fp, context->u.s.Lr, context->Sp ); return STATUS_SUCCESS; +} +#endif + +/*********************************************************************** + * unwind_builtin_dll + * + * Equivalent of RtlVirtualUnwind for builtin modules. + */ +NTSTATUS CDECL unwind_builtin_dll( ULONG type, DISPATCHER_CONTEXT *dispatch, CONTEXT *context ) +{ + struct dwarf_eh_bases bases; + const struct dwarf_fde *fde = _Unwind_Find_FDE( (void *)(context->Pc - 1), &bases ); + + if (fde) + return dwarf_virtual_unwind( context->Pc, &dispatch->EstablisherFrame, context, fde, + &bases, &dispatch->LanguageHandler, &dispatch->HandlerData ); +#ifdef HAVE_LIBUNWIND + return libunwind_virtual_unwind( context->Pc, &dispatch->EstablisherFrame, context, + &dispatch->LanguageHandler, &dispatch->HandlerData ); #else ERR("libunwind not available, unable to unwind\n"); return STATUS_INVALID_DISPOSITION;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Martin Storsjö

10:03 a.m.

New subject: [PATCH 4/5] ntdll: Add ARM EHABI unwind instructions in assembly functions

From: Martin Storsjö martin@martin.st

On most ELF platforms on ARM, ARM EHABI is the unwind info format normally used, instead of DWARF like on most other platforms.

Currently, when unwinding through ELF objects with libunwind, the libraries don't have any .eh_frame section mapped at runtime (since DWARF isn't used for unwinding). Instead, what happens is that libunwind ends up loading .debug_frame from the libraries on disk instead.

Therefore, currently, ELF unwinding relies on the .so files not being stripped.

This patch adds the necessary EHABI unwinding instructions in the assembly functions that currently have DWARF CFI instructions.

EHABI isn't signaled via any specific preprocessor macro, but is signaled by the absence of other unwind mechanisms (such as __ARM_DWARF_EH__ and __SEH__, or maybe SjLj).

Mark the asm functions in the preloaders as .cantunwind, to avoid undefined references to __aeabi_unwind_cpp_pr* functions.

Also mark other assembly functions as .cantunwind; for signal_exit_thread this is essential if the function is marked with .fnstart/.fnend - otherwise exiting threads does hang. (pthread_exit internally calls _Unwind_ForcedUnwind, which would hang if signal_exit_thread had .fnstart without any matching unwind info).

This would, in principle, allow unwinding through these functions with libunwind, for versions of libunwind that can parse the EHABI unwind info - see e.g. https://github.com/libunwind/libunwind/commit/4d779f55c0d0a3814453517e54cd0f.... (This commit isn't yet in any current release AFAIK). Unwinding with EHABI via libunwind would require a few tweaks to the libunwind interface usage in unix/signal_arm.c though, since e.g. the unw_get_proc_info call fails if there's no .eh_frame or .debug_frame available.

Signed-off-by: Martin Storsjö martin@martin.st --- dlls/ntdll/signal_arm.c | 15 +++++++++++++++ dlls/ntdll/unix/signal_arm.c | 10 ++++++++++ include/wine/asm.h | 8 +++++++- loader/preloader.c | 3 +++ 4 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/dlls/ntdll/signal_arm.c b/dlls/ntdll/signal_arm.c index c3674487277..0952be6ba33 100644 --- a/dlls/ntdll/signal_arm.c +++ b/dlls/ntdll/signal_arm.c @@ -1129,6 +1129,18 @@ __ASM_GLOBAL_FUNC( call_consolidate_callback, __ASM_CFI(".cfi_escape 0x10,0x8e,0x02,0x03,0x7d,0xc0,0x01\n\t") /* DW_CFA_expression: D14 DW_OP_breg13 + 192 */ __ASM_CFI(".cfi_escape 0x10,0x8f,0x02,0x03,0x7d,0xc8,0x01\n\t") /* DW_CFA_expression: D15 DW_OP_breg13 + 200 */ #endif + /* These EHABI opcodes are to be read bottom up - they + * restore relevant registers from the CONTEXT. */ + __ASM_EHABI(".save {sp}\n\t") /* Restore Sp last */ + __ASM_EHABI(".pad #-(0x80 + 0x0c + 0x0c)\n\t") /* Move back across D0-D15, Cpsr, Fpscr, Padding, Pc, Lr and Sp */ + __ASM_EHABI(".vsave {d8-d15}\n\t") + __ASM_EHABI(".pad #0x40\n\t") /* Skip past D0-D7 */ + __ASM_EHABI(".pad #0x0c\n\t") /* Skip past Cpsr, Fpscr and Padding */ + __ASM_EHABI(".save {lr, pc}\n\t") + __ASM_EHABI(".pad #0x08\n\t") /* Skip past R12 and Sp - Sp is restored last */ + __ASM_EHABI(".save {r4-r11}\n\t") + __ASM_EHABI(".pad #0x14\n\t") /* Skip past ContextFlags and R0-R3 */ + "ldrd r1, r2, [sp, #0x1a4]\n\t" "mov r0, r2\n\t" "blx r1\n\t" @@ -1327,6 +1339,7 @@ extern LONG __C_ExecuteExceptionFilter(PEXCEPTION_POINTERS ptrs, PVOID frame, PUCHAR nonvolatile); __ASM_GLOBAL_FUNC( __C_ExecuteExceptionFilter, "push {r4-r11,lr}\n\t" + __ASM_EHABI(".save {r4-r11,lr}\n\t") __ASM_SEH(".seh_save_regs_w {r4-r11,lr}\n\t") __ASM_SEH(".seh_endprologue\n\t")

@@ -1439,8 +1452,10 @@ EXCEPTION_DISPOSITION WINAPI __C_specific_handler( EXCEPTION_RECORD *rec, */ __ASM_STDCALL_FUNC( RtlRaiseException, 4, "push {r0, lr}\n\t" + __ASM_EHABI(".save {r0, lr}\n\t") __ASM_SEH(".seh_save_regs {r0, lr}\n\t") "sub sp, sp, #0x1a0\n\t" /* sizeof(CONTEXT) */ + __ASM_EHABI(".pad #0x1a0\n\t") __ASM_SEH(".seh_stackalloc 0x1a0\n\t") __ASM_SEH(".seh_endprologue\n\t") __ASM_CFI(".cfi_adjust_cfa_offset 424\n\t") diff --git a/dlls/ntdll/unix/signal_arm.c b/dlls/ntdll/unix/signal_arm.c index 5d1478a1ff4..add01687c4b 100644 --- a/dlls/ntdll/unix/signal_arm.c +++ b/dlls/ntdll/unix/signal_arm.c @@ -593,6 +593,11 @@ __ASM_GLOBAL_FUNC( raise_func_trampoline, "push {r3}\n\t" /* Original Sp */ __ASM_CFI(".cfi_escape 0x0f,0x03,0x7D,0x04,0x06\n\t") /* CFA, DW_OP_breg13 + 0x04, DW_OP_deref */ __ASM_CFI(".cfi_escape 0x10,0x0e,0x02,0x7D,0x0c\n\t") /* LR, DW_OP_breg13 + 0x0c */ + __ASM_EHABI(".save {sp}\n\t") + __ASM_EHABI(".pad #-12\n\t") + __ASM_EHABI(".save {pc}\n\t") + __ASM_EHABI(".pad #8\n\t") + __ASM_EHABI(".save {lr}\n\t") /* We can't express restoring both Pc and Lr with CFI * directives, but we manually load Lr from the stack * in unwind_builtin_dll above. */ @@ -1171,6 +1176,7 @@ void DECLSPEC_HIDDEN call_init_thunk( LPTHREAD_START_ROUTINE entry, void *arg, B * signal_start_thread */ __ASM_GLOBAL_FUNC( signal_start_thread, + __ASM_EHABI(".cantunwind\n\t") "push {r4-r12,lr}\n\t" /* store exit frame */ "str sp, [r3, #0x1d4]\n\t" /* arm_thread_data()->exit_frame */ @@ -1187,6 +1193,7 @@ __ASM_GLOBAL_FUNC( signal_start_thread, * signal_exit_thread */ __ASM_GLOBAL_FUNC( signal_exit_thread, + __ASM_EHABI(".cantunwind\n\t") "ldr r3, [r2, #0x1d4]\n\t" /* arm_thread_data()->exit_frame */ "mov ip, #0\n\t" "str ip, [r2, #0x1d4]\n\t" @@ -1200,6 +1207,7 @@ __ASM_GLOBAL_FUNC( signal_exit_thread, * __wine_syscall_dispatcher */ __ASM_GLOBAL_FUNC( __wine_syscall_dispatcher, + __ASM_EHABI(".cantunwind\n\t") "mrc p15, 0, r1, c13, c0, 2\n\t" /* NtCurrentTeb() */ "ldr r1, [r1, #0x1d8]\n\t" /* arm_thread_data()->syscall_frame */ "add r0, r1, #0x10\n\t" @@ -1276,6 +1284,7 @@ __ASM_GLOBAL_FUNC( __wine_syscall_dispatcher, * __wine_setjmpex */ __ASM_GLOBAL_FUNC( __wine_setjmpex, + __ASM_EHABI(".cantunwind\n\t") "stm r0, {r1,r4-r11}\n" /* jmp_buf->Frame,R4..R11 */ "str sp, [r0, #0x24]\n\t" /* jmp_buf->Sp */ "str lr, [r0, #0x28]\n\t" /* jmp_buf->Pc */ @@ -1293,6 +1302,7 @@ __ASM_GLOBAL_FUNC( __wine_setjmpex, * __wine_longjmp */ __ASM_GLOBAL_FUNC( __wine_longjmp, + __ASM_EHABI(".cantunwind\n\t") "ldm r0, {r3-r11}\n\t" /* jmp_buf->Frame,R4..R11 */ "ldr sp, [r0, #0x24]\n\t" /* jmp_buf->Sp */ "ldr r2, [r0, #0x28]\n\t" /* jmp_buf->Pc */ diff --git a/include/wine/asm.h b/include/wine/asm.h index 2c996ccd86b..2448f591189 100644 --- a/include/wine/asm.h +++ b/include/wine/asm.h @@ -41,6 +41,12 @@ # define __ASM_CFI(str) #endif

+#if defined(__arm__) && defined(__ELF__) && defined(__GNUC__) && !defined(__SEH__) && !defined(__ARM_DWARF_EH__) +# define __ASM_EHABI(str) str +#else +# define __ASM_EHABI(str) +#endif + #if defined(__SEH__) || (defined(_MSC_VER) && defined(__clang__) && (defined(__x86_64__) || defined(__aarch64__))) # if defined(__aarch64__) && defined(__clang_major__) && (__clang_major__ < 12 || defined(__apple_build_version__)) /* Clang got support for aarch64 SEH assembly directives in Clang 12, @@ -86,7 +92,7 @@ #define __ASM_DEFINE_FUNC(name,code) \ __ASM_BLOCK_BEGIN(__LINE__) \ asm(".text\n\t.align 4\n\t.globl " name "\n\t" __ASM_FUNC_TYPE(name) __ASM_SEH("\n\t.seh_proc " name) "\n" name ":\n\t" \ - __ASM_CFI(".cfi_startproc\n\t") code __ASM_CFI("\n\t.cfi_endproc") __ASM_SEH("\n\t.seh_endproc") __ASM_FUNC_SIZE(name)); \ + __ASM_CFI(".cfi_startproc\n\t") __ASM_EHABI(".fnstart\n\t") code __ASM_CFI("\n\t.cfi_endproc") __ASM_EHABI("\n\t.fnend") __ASM_SEH("\n\t.seh_endproc") __ASM_FUNC_SIZE(name)); \ __ASM_BLOCK_END

#define __ASM_GLOBAL_FUNC(name,code) __ASM_DEFINE_FUNC(__ASM_NAME(#name),code) diff --git a/loader/preloader.c b/loader/preloader.c index d88964e9c4b..72556f09720 100644 --- a/loader/preloader.c +++ b/loader/preloader.c @@ -542,6 +542,7 @@ void *thread_data[256]; void _start(void); extern char _end[]; __ASM_GLOBAL_FUNC(_start, + __ASM_EHABI(".cantunwind\n\t") "mov r0, sp\n\t" "sub sp, sp, #144\n\t" /* allocate some space for extra aux values */ "str r0, [sp]\n\t" /* orig stack pointer */ @@ -564,6 +565,7 @@ __ASM_GLOBAL_FUNC(_start,

#define SYSCALL_FUNC( name, nr ) \ __ASM_GLOBAL_FUNC( name, \ + __ASM_EHABI(".cantunwind\n\t") \ "push {r4-r5,r7,lr}\n\t" \ "ldr r4, [sp, #16]\n\t" \ "ldr r5, [sp, #20]\n\t" \ @@ -576,6 +578,7 @@ __ASM_GLOBAL_FUNC(_start,

#define SYSCALL_NOERR( name, nr ) \ __ASM_GLOBAL_FUNC( name, \ + __ASM_EHABI(".cantunwind\n\t") \ "push {r7,lr}\n\t" \ "mov r7, #" #nr "\n\t" \ "svc #0\n\t" \

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Martin Storsjö

10:03 a.m.

New subject: [PATCH 5/5] ntdll: Implement ARM EHABI unwinding

From: Martin Storsjö martin@martin.st

This avoids relying on libunwind, which isn't always available, and which can be brittle (e.g. current git master of libunwind fails, see https://github.com/libunwind/libunwind/pull/203#issuecomment-984126066).

This allows unwinding with the EXIDX/EXTBL info which is used normally for C++ exception handling/unwinding. This avoids needing to keep the .so files unstripped and avoids needing libunwind to load .debug_frame from disk instead of the already mapped EXIDX/EXTBL.

This patch uses the dl_iterate_phdr function for finding the EXIDX section; keeping this call within #ifdef linux to avoid breaking someone's build, even though it probably is available on most unix (or ELF) platforms.

Alternatively, we could add configure checks for this function.

This passes all my unwinding tests, for full ELF builds of Wine, built with both GCC and Clang. (It also works for PE builds, where only very few ELF bits need to be unwound.)

Signed-off-by: Martin Storsjö martin@martin.st --- dlls/ntdll/unix/signal_arm.c | 387 ++++++++++++++++++++++++++++++++++- 1 file changed, 378 insertions(+), 9 deletions(-)

diff --git a/dlls/ntdll/unix/signal_arm.c b/dlls/ntdll/unix/signal_arm.c index add01687c4b..4190d166ed5 100644 --- a/dlls/ntdll/unix/signal_arm.c +++ b/dlls/ntdll/unix/signal_arm.c @@ -55,6 +55,9 @@ # define UNW_LOCAL_ONLY # include <libunwind.h> #endif +#ifdef HAVE_LINK_H +# include <link.h> +#endif

#define NONAMELESSUNION #define NONAMELESSSTRUCT @@ -223,13 +226,360 @@ static BOOL is_inside_syscall( ucontext_t *sigcontext )

extern void raise_func_trampoline( EXCEPTION_RECORD *rec, CONTEXT *context, void *dispatcher );

+struct exidx_entry { + uint32_t addr; + uint32_t data; +}; + +static uint32_t prel31_to_abs(const uint32_t *ptr) +{ + uint32_t prel31 = *ptr; + uint32_t rel = prel31 | ((prel31 << 1) & 0x80000000); + return (uintptr_t)ptr + rel; +} + +static uint8_t get_byte(const uint32_t *ptr, int offset, int bytes) +{ + int word = offset >> 2; + int byte = offset & 0x3; + if (offset >= bytes) + return 0xb0; /* finish opcode */ + return (ptr[word] >> (24 - 8*byte)) & 0xff; +} + +static uint32_t get_uleb128(const uint32_t *ptr, int *offset, int bytes) +{ + int shift = 0; + uint32_t val = 0; + while (1) { + uint8_t byte = get_byte(ptr, (*offset)++, bytes); + val |= (byte & 0x7f) << shift; + if ((byte & 0x80) == 0) + break; + shift += 7; + } + return val; +} + +static void pop_regs(CONTEXT *context, uint32_t regs) +{ + int i; + DWORD new_sp = 0; + for (i = 0; i < 16; i++) { + if (regs & (1U << i)) { + DWORD val = *(DWORD *)context->Sp; + if (i != 13) + (&context->R0)[i] = val; + else + new_sp = val; + context->Sp += 4; + } + } + if (regs & (1 << 13)) + context->Sp = new_sp; +} + +static void pop_vfp(CONTEXT *context, int first, int last) +{ + int i; + for (i = first; i <= last; i++) { + context->u.D[i] = *(ULONGLONG *)context->Sp; + context->Sp += 8; + } +} + +static uint32_t regmask(int first_bit, int n_bits) +{ + return ((1U << (n_bits + 1)) - 1) << first_bit; +} + /*********************************************************************** - * unwind_builtin_dll + * ehabi_virtual_unwind */ -NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispatch, CONTEXT *context ) +static NTSTATUS ehabi_virtual_unwind( DWORD ip, DWORD *frame, CONTEXT *context, + const struct exidx_entry *entry, + PEXCEPTION_ROUTINE *handler, void **handler_data ) +{ + const uint32_t *ptr; + const void *lsda = NULL; + int compact_inline = 0; + int offset = 0; + int bytes = 0; + int personality; + int extra_words; + int finish = 0; + int set_pc = 0; + DWORD func_begin = prel31_to_abs(&entry->addr); + + *frame = context->Sp; + + TRACE( "ip %#x function %#lx\n", + ip, (unsigned long)func_begin ); + + if (entry->data == 1) { + ERR("EXIDX_CANTUNWIND\n"); + return STATUS_UNSUCCESSFUL; + } else if (entry->data & 0x80000000) { + if ((entry->data & 0x7f000000) != 0) { + ERR("compact inline EXIDX must have personality 0\n"); + return STATUS_UNSUCCESSFUL; + } + ptr = &entry->data; + compact_inline = 1; + } else { + ptr = (uint32_t *)prel31_to_abs(&entry->data); + } + + if ((*ptr & 0x80000000) == 0) { + /* Generic */ + void *personality_func = (void *)prel31_to_abs(ptr); + int words = (ptr[1] >> 24) & 0xff; + lsda = ptr + 1 + words + 1; + + ERR("generic EHABI unwinding not supported\n"); + (void)personality_func; + return STATUS_UNSUCCESSFUL; + } + + /* Compact */ + + personality = (*ptr >> 24) & 0x0f; + switch (personality) { + case 0: + if (!compact_inline) + lsda = ptr + 1; + extra_words = 0; + offset = 1; + break; + case 1: + extra_words = (*ptr >> 16) & 0xff; + lsda = ptr + extra_words + 1; + offset = 2; + break; + case 2: + extra_words = (*ptr >> 16) & 0xff; + lsda = ptr + extra_words + 1; + offset = 2; + break; + default: + ERR("unsupported compact EXIDX personality %d\n", personality); + return STATUS_UNSUCCESSFUL; + } + + /* Not inspecting the descriptors */ + (void)lsda; + + bytes = 4 + 4*extra_words; + while (offset < bytes && !finish) { + uint8_t byte = get_byte(ptr, offset++, bytes); + if ((byte & 0xc0) == 0x00) { + /* Increment Sp */ + context->Sp += (byte & 0x3f) * 4 + 4; + } else if ((byte & 0xc0) == 0x40) { + /* Decrement Sp */ + context->Sp -= (byte & 0x3f) * 4 + 4; + } else if ((byte & 0xf0) == 0x80) { + /* Pop {r4-r15} based on register mask */ + int regs = ((byte & 0x0f) << 8) | get_byte(ptr, offset++, bytes); + if (!regs) { + ERR("refuse to unwind\n"); + return STATUS_UNSUCCESSFUL; + } + regs <<= 4; + pop_regs(context, regs); + if (regs & (1 << 15)) + set_pc = 1; + } else if ((byte & 0xf0) == 0x90) { + /* Restore Sp from other register */ + int reg = byte & 0x0f; + if (reg == 13 || reg == 15) { + ERR("reserved opcode\n"); + return STATUS_UNSUCCESSFUL; + } + context->Sp = (&context->R0)[reg]; + } else if ((byte & 0xf0) == 0xa0) { + /* Pop r4-r(4+n) (+lr) */ + int n = byte & 0x07; + int regs = regmask(4, n); + if (byte & 0x08) + regs |= 1 << 14; + pop_regs(context, regs); + } else if (byte == 0xb0) { + finish = 1; + } else if (byte == 0xb1) { + /* Pop {r0-r3} based on register mask */ + int regs = get_byte(ptr, offset++, bytes); + if (regs == 0 || (regs & 0xf0) != 0) { + ERR("spare opcode\n"); + return STATUS_UNSUCCESSFUL; + } + pop_regs(context, regs); + } else if (byte == 0xb2) { + /* Increment Sp by a larger amount */ + int imm = get_uleb128(ptr, &offset, bytes); + context->Sp += 0x204 + imm * 4; + } else if (byte == 0xb3) { + /* Pop VFP registers as if saved by FSTMFDX; this opcode + * is deprecated. */ + ERR("FSTMFDX unsupported\n"); + return STATUS_UNSUCCESSFUL; + } else if ((byte & 0xfc) == 0xb4) { + ERR("spare opcode\n"); + return STATUS_UNSUCCESSFUL; + } else if ((byte & 0xf8) == 0xb8) { + /* Pop VFP registers as if saved by FSTMFDX; this opcode + * is deprecated. */ + ERR("FSTMFDX unsupported\n"); + return STATUS_UNSUCCESSFUL; + } else if ((byte & 0xf8) == 0xc0) { + ERR("spare opcode / iWMMX\n"); + return STATUS_UNSUCCESSFUL; + } else if ((byte & 0xfe) == 0xc8) { + /* Pop VFP registers d(16+ssss)-d(16+ssss+cccc), or + * d(0+ssss)-d(0+ssss+cccc) as if saved by VPUSH */ + int first, last; + if ((byte & 0x01) == 0) + first = 16; + else + first = 0; + byte = get_byte(ptr, offset++, bytes); + first += (byte & 0xf0) >> 4; + last = first + (byte & 0x0f); + if (last >= 32) { + ERR("reserved opcode\n"); + return STATUS_UNSUCCESSFUL; + } + pop_vfp(context, first, last); + } else if ((byte & 0xf8) == 0xc8) { + ERR("spare opcode\n"); + return STATUS_UNSUCCESSFUL; + } else if ((byte & 0xf8) == 0xd0) { + /* Pop VFP registers d8-d(8+n) as if saved by VPUSH */ + int n = byte & 0x07; + pop_vfp(context, 8, 8 + n); + } else { + ERR("spare opcode\n"); + return STATUS_UNSUCCESSFUL; + } + } + if (offset > bytes) { + ERR("truncated opcodes\n"); + return STATUS_UNSUCCESSFUL; + } + + *handler = NULL; /* personality */ + *handler_data = NULL; /* lsda */ + + context->ContextFlags |= CONTEXT_UNWOUND_TO_CALL; + if (!set_pc) + context->Pc = context->Lr; + + /* There's no need to check for raise_func_trampoline and manually restore + * Lr separately from Pc like with libunwind; the EHABI unwind info + * describes how both of them are restored separately, and as long as + * the unwind info restored Pc, it doesn't have to be set from Lr. */ + + TRACE( "next function pc=%08x\n", context->Pc ); + TRACE(" r0=%08x r1=%08x r2=%08x r3=%08x\n", + context->R0, context->R1, context->R2, context->R3 ); + TRACE(" r4=%08x r5=%08x r6=%08x r7=%08x\n", + context->R4, context->R5, context->R6, context->R7 ); + TRACE(" r8=%08x r9=%08x r10=%08x r11=%08x\n", + context->R8, context->R9, context->R10, context->R11 ); + TRACE(" r12=%08x sp=%08x lr=%08x pc=%08x\n", + context->R12, context->Sp, context->Lr, context->Pc ); + + return STATUS_SUCCESS; +} + +#ifdef linux +struct iterate_data { + ULONG_PTR ip; + int failed; + struct exidx_entry *entry; +}; + +static int contains_addr(struct dl_phdr_info *info, const ElfW(Phdr) *phdr, struct iterate_data *data) { + if (phdr->p_type != PT_LOAD) + return 0; + return data->ip >= info->dlpi_addr + phdr->p_vaddr && data->ip < info->dlpi_addr + phdr->p_vaddr + phdr->p_memsz; +} + +static int check_exidx(struct dl_phdr_info *info, size_t info_size, void *arg) +{ + struct iterate_data *data = arg; + int i; + int found_addr; + const ElfW(Phdr) *exidx = NULL; + struct exidx_entry *begin, *end; + + if (info->dlpi_phnum == 0 || data->ip < info->dlpi_addr || data->failed) + return 0; + + found_addr = 0; + for (i = 0; i < info->dlpi_phnum; i++) { + const ElfW(Phdr) *phdr = &info->dlpi_phdr[i]; + if (contains_addr(info, phdr, data)) + found_addr = 1; + if (phdr->p_type == SHT_ARM_EXIDX) + exidx = phdr; + } + + if (!found_addr || !exidx) { + if (found_addr) { + TRACE("found matching address in %s, but no EXIDX\n", info->dlpi_name); + data->failed = 1; + } + return 0; + } + + begin = (struct exidx_entry *)(info->dlpi_addr + exidx->p_vaddr); + end = (struct exidx_entry *)(info->dlpi_addr + exidx->p_vaddr + exidx->p_memsz); + if (data->ip < prel31_to_abs(&begin->addr)) { + TRACE("%lx before EXIDX start at %x\n", data->ip, prel31_to_abs(&begin->addr)); + data->failed = 1; + return 0; + } + + while (begin + 1 < end) { + struct exidx_entry *mid = begin + (end - begin)/2; + uint32_t abs_addr = prel31_to_abs(&mid->addr); + if (abs_addr > data->ip) { + end = mid; + } else if (abs_addr < data->ip) { + begin = mid; + } else { + begin = mid; + end = mid + 1; + } + } + + data->entry = begin; + TRACE("found %lx in %s, base %x, entry %p with addr %x (rel %x) data %x\n", + data->ip, info->dlpi_name, info->dlpi_addr, begin, + prel31_to_abs(&begin->addr), + prel31_to_abs(&begin->addr) - info->dlpi_addr, begin->data); + return 1; +} + +static const struct exidx_entry *find_exidx_entry( void *ip ) +{ + struct iterate_data data = {}; + + data.ip = (ULONG_PTR)ip; + data.failed = 0; + data.entry = NULL; + dl_iterate_phdr(check_exidx, &data); + + return data.entry; +} +#endif + #ifdef HAVE_LIBUNWIND - DWORD ip = context->Pc - (dispatch->ControlPcIsUnwound ? 2 : 0); +static NTSTATUS libunwind_virtual_unwind( DWORD ip, DWORD *frame, CONTEXT *context, + PEXCEPTION_ROUTINE *handler, void **handler_data ) +{ unw_context_t unw_context; unw_cursor_t cursor; unw_proc_info_t info; @@ -261,8 +611,8 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispa TRACE( "no info found for %x ip %x-%x, %s\n", ip, info.start_ip, info.end_ip, status == STATUS_SUCCESS ? "assuming leaf function" : "error, stuck" ); - dispatch->LanguageHandler = NULL; - dispatch->EstablisherFrame = context->Sp; + *handler = NULL; + *frame = context->Sp; context->Pc = context->Lr; context->ContextFlags |= CONTEXT_UNWOUND_TO_CALL; return status; @@ -279,9 +629,9 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispa return STATUS_INVALID_DISPOSITION; }

for (i = 0; i <= 12; i++) unw_get_reg( &cursor, UNW_ARM_R0 + i, (unw_word_t *)&(&context->R0)[i] ); @@ -297,7 +647,7 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispa * individual values, thus do that manually here. * (The function we unwind to might be a leaf function that hasn't * backed up its own original Lr value on the stack.) */ - const DWORD *orig_lr = (const DWORD *) dispatch->EstablisherFrame; + const DWORD *orig_lr = (const DWORD *) *frame; context->Lr = *orig_lr; }

@@ -311,6 +661,25 @@ NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispa TRACE(" r12=%08x sp=%08x lr=%08x pc=%08x\n", context->R12, context->Sp, context->Lr, context->Pc ); return STATUS_SUCCESS; +} +#endif + +/*********************************************************************** + * unwind_builtin_dll + */ +NTSTATUS CDECL unwind_builtin_dll( ULONG type, struct _DISPATCHER_CONTEXT *dispatch, CONTEXT *context ) +{ + DWORD ip = context->Pc - (dispatch->ControlPcIsUnwound ? 2 : 0); +#ifdef linux + const struct exidx_entry *entry = find_exidx_entry( (void *)ip ); + + if (entry) + return ehabi_virtual_unwind( ip, &dispatch->EstablisherFrame, context, entry, + &dispatch->LanguageHandler, &dispatch->HandlerData ); +#endif +#ifdef HAVE_LIBUNWIND + return libunwind_virtual_unwind( ip, &dispatch->EstablisherFrame, context, + &dispatch->LanguageHandler, &dispatch->HandlerData ); #else ERR("libunwind not available, unable to unwind\n"); return STATUS_INVALID_DISPOSITION;

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/1134

Marvin

11:01 a.m.

New subject: [PATCH 5/5] ntdll: Implement ARM EHABI unwinding

Hi,

It looks like your patch introduced the new failures shown below. Please investigate and fix them before resubmitting your patch. If they are not new, fixing them anyway would help a lot. Otherwise please ask for the known failures list to be updated.

The full results can be found at: https://testbot.winehq.org/JobDetails.pl?Key=125238

Your paranoid android.

=== debian11 (build log) ===

Task: Could not create the win32 wineprefix: Failed to disable the crash dialogs: Task: WineTest did not produce the win32 report

Martin Storsjö (＠mstorsjo)

10:13 a.m.

Also if you'd prefer, I can split the MR into one for ARM and one for ARM64, if that's easier for getting either side in an acceptable shape sooner. The patches for each arch are entirely independent of each other - even if they're aimed at the same goal.

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/1134#note_11684

840

Age (days ago)

840

Last active (days ago)

wine-gitlab@winehq.org

7 comments

3 participants

tags (0)

participants (3)

Martin Storsjö
Martin Storsjö (＠mstorsjo)
Marvin