X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmini%2Funwind.c;h=2377e0dd009b5e970a01d2732dc2584f943e4458;hb=e2b2d181084848f3c5dde2788370db1b79893c69;hp=a0b731cedcb99e8541a95fbb66e216c0e9f1dcbe;hpb=26f0a0b805a252d562ded669c5b558f48333b6e3;p=mono.git diff --git a/mono/mini/unwind.c b/mono/mini/unwind.c index a0b731cedcb..2377e0dd009 100644 --- a/mono/mini/unwind.c +++ b/mono/mini/unwind.c @@ -11,7 +11,10 @@ #include "mini-unwind.h" #include +#include +#include #include +#include typedef enum { LOC_SAME, @@ -32,6 +35,7 @@ static CRITICAL_SECTION unwind_mutex; static MonoUnwindInfo **cached_info; static int cached_info_next, cached_info_size; +static GSList *cached_info_list; /* Statistics */ static int unwind_info_size; @@ -50,7 +54,16 @@ static int map_hw_reg_to_dwarf_reg [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, #define DWARF_DATA_ALIGN (-4) #define DWARF_PC_REG (mono_hw_reg_to_dwarf_reg (ARMREG_LR)) #elif defined (TARGET_X86) +#ifdef __APPLE__ +/* + * LLVM seems to generate unwind info where esp is encoded as 5, and ebp as 4, ie see this line: + * def ESP : RegisterWithSubRegs<"esp", [SP]>, DwarfRegNum<[-2, 5, 4]>; + * in lib/Target/X86/X86RegisterInfo.td in the llvm sources. + */ +static int map_hw_reg_to_dwarf_reg [] = { 0, 1, 2, 3, 5, 4, 6, 7, 8 }; +#else static int map_hw_reg_to_dwarf_reg [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; +#endif /* + 1 is for IP */ #define NUM_REGS X86_NREG + 1 #define DWARF_DATA_ALIGN (-4) @@ -64,6 +77,22 @@ static int map_hw_reg_to_dwarf_reg [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, #define NUM_REGS 110 #define DWARF_DATA_ALIGN (-(gint32)sizeof (mgreg_t)) #define DWARF_PC_REG 108 +#elif defined (TARGET_S390X) +static int map_hw_reg_to_dwarf_reg [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; +#define NUM_REGS 16 +#define DWARF_DATA_ALIGN (-8) +#define DWARF_PC_REG (mono_hw_reg_to_dwarf_reg (14)) +#elif defined (TARGET_MIPS) +/* FIXME: */ +static int map_hw_reg_to_dwarf_reg [32] = { + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31 +}; +#define NUM_REGS 32 +#define DWARF_DATA_ALIGN (-(gint32)sizeof (mgreg_t)) +#define DWARF_PC_REG (mono_hw_reg_to_dwarf_reg (mips_ra)) #else static int map_hw_reg_to_dwarf_reg [16]; #define NUM_REGS 16 @@ -116,7 +145,7 @@ init_reg_map (void) dwarf_reg_to_hw_reg_inited = TRUE; } -static inline int +int mono_dwarf_reg_to_hw_reg (int reg) { if (!dwarf_reg_to_hw_reg_inited) @@ -317,12 +346,16 @@ print_dwarf_state (int cfa_reg, int cfa_offset, int ip, int nregs, Loc *location * Given the state of the current frame as stored in REGS, execute the unwind * operations in unwind_info until the location counter reaches POS. The result is * stored back into REGS. OUT_CFA will receive the value of the CFA. + * If SAVE_LOCATIONS is non-NULL, it should point to an array of size SAVE_LOCATIONS_LEN. + * On return, the nth entry will point to the address of the stack slot where register + * N was saved, or NULL, if it was not saved by this frame. * This function is signal safe. */ void mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len, - guint8 *start_ip, guint8 *end_ip, guint8 *ip, mgreg_t *regs, - int nregs, guint8 **out_cfa) + guint8 *start_ip, guint8 *end_ip, guint8 *ip, mgreg_t *regs, int nregs, + mgreg_t **save_locations, int save_locations_len, + guint8 **out_cfa) { Loc locations [NUM_REGS]; int i, pos, reg, cfa_reg, cfa_offset; @@ -371,7 +404,7 @@ mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len, locations [reg].offset = decode_sleb128 (p, &p) * DWARF_DATA_ALIGN; break; case DW_CFA_advance_loc4: - pos += *(guint32*)p; + pos += read32 (p); p += 4; break; default: @@ -384,12 +417,17 @@ mono_unwind_frame (guint8 *unwind_info, guint32 unwind_info_len, } } + if (save_locations) + memset (save_locations, 0, save_locations_len * sizeof (mgreg_t*)); + cfa_val = (guint8*)regs [mono_dwarf_reg_to_hw_reg (cfa_reg)] + cfa_offset; for (i = 0; i < NUM_REGS; ++i) { if (locations [i].loc_type == LOC_OFFSET) { int hreg = mono_dwarf_reg_to_hw_reg (i); g_assert (hreg < nregs); regs [hreg] = *(mgreg_t*)(cfa_val + locations [i].offset); + if (save_locations && hreg < save_locations_len) + save_locations [hreg] = (mgreg_t*)(cfa_val + locations [i].offset); } } @@ -465,8 +503,8 @@ mono_cache_unwind_info (guint8 *unwind_info, guint32 unwind_info_len) MonoUnwindInfo **old_table, **new_table; /* - * Have to resize the table, while synchronizing with - * mono_get_cached_unwind_info () using hazard pointers. + * Avoid freeing the old table so mono_get_cached_unwind_info () + * doesn't need locks/hazard pointers. */ old_table = cached_info; @@ -478,9 +516,7 @@ mono_cache_unwind_info (guint8 *unwind_info, guint32 unwind_info_len) cached_info = new_table; - mono_memory_barrier (); - - mono_thread_hazardous_free_or_queue (old_table, g_free); + cached_info_list = g_slist_prepend (cached_info_list, cached_info); cached_info_size *= 2; } @@ -493,32 +529,6 @@ mono_cache_unwind_info (guint8 *unwind_info, guint32 unwind_info_len) return i; } -static gpointer -get_hazardous_pointer (gpointer volatile *pp, MonoThreadHazardPointers *hp, int hazard_index) -{ - gpointer p; - - for (;;) { - /* Get the pointer */ - p = *pp; - /* If we don't have hazard pointers just return the - pointer. */ - if (!hp) - return p; - /* Make it hazardous */ - mono_hazard_pointer_set (hp, hazard_index, p); - /* Check that it's still the same. If not, try - again. */ - if (*pp != p) { - mono_hazard_pointer_clear (hp, hazard_index); - continue; - } - break; - } - - return p; -} - /* * This function is signal safe. */ @@ -528,17 +538,18 @@ mono_get_cached_unwind_info (guint32 index, guint32 *unwind_info_len) MonoUnwindInfo **table; MonoUnwindInfo *info; guint8 *data; - MonoThreadHazardPointers *hp = mono_hazard_pointer_get (); - table = get_hazardous_pointer ((gpointer volatile*)&cached_info, hp, 0); + /* + * This doesn't need any locks/hazard pointers, + * since new tables are copies of the old ones. + */ + table = cached_info; info = table [index]; *unwind_info_len = info->len; data = info->info; - mono_hazard_pointer_clear (hp, 0); - return data; } @@ -595,6 +606,10 @@ decode_cie_op (guint8 *p, guint8 **endp) case DW_CFA_advance_loc4: p += 4; break; + case DW_CFA_offset_extended_sf: + decode_uleb128 (p, &p); + decode_uleb128 (p, &p); + break; default: g_assert_not_reached (); } @@ -607,24 +622,6 @@ decode_cie_op (guint8 *p, guint8 **endp) *endp = p; } -/* Pointer Encoding in the .eh_frame */ -enum { - DW_EH_PE_absptr = 0x00, - DW_EH_PE_omit = 0xff, - - DW_EH_PE_udata4 = 0x03, - DW_EH_PE_sdata4 = 0x0b, - DW_EH_PE_sdata8 = 0x0c, - - DW_EH_PE_pcrel = 0x10, - DW_EH_PE_textrel = 0x20, - DW_EH_PE_datarel = 0x30, - DW_EH_PE_funcrel = 0x40, - DW_EH_PE_aligned = 0x50, - - DW_EH_PE_indirect = 0x80 -}; - static gint64 read_encoded_val (guint32 encoding, guint8 *p, guint8 **endp) { @@ -653,7 +650,7 @@ read_encoded_val (guint32 encoding, guint8 *p, guint8 **endp) * Decode the Language Specific Data Area generated by LLVM. */ static void -decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info) +decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info, int *this_reg, int *this_offset) { gint32 ttype_offset, call_site_length; gint32 ttype_encoding, call_site_encoding; @@ -666,9 +663,34 @@ decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 */ p = lsda; - /* Read @LPStart */ - g_assert (*p == DW_EH_PE_omit); - p ++; + if (*p == DW_EH_PE_udata4) { + /* This is the modified LSDA generated by the LLVM mono branch */ + guint32 mono_magic, version; + gint32 op, reg, offset; + + p ++; + mono_magic = decode_uleb128 (p, &p); + g_assert (mono_magic == 0x4d4fef4f); + version = decode_uleb128 (p, &p); + g_assert (version == 1); + + /* 'this' location */ + op = *p; + g_assert (op == DW_OP_bregx); + p ++; + reg = decode_uleb128 (p, &p); + offset = decode_sleb128 (p, &p); + + *this_reg = mono_dwarf_reg_to_hw_reg (reg); + *this_offset = offset; + } else { + /* Read @LPStart */ + g_assert (*p == DW_EH_PE_omit); + p ++; + + *this_reg = -1; + *this_offset = -1; + } /* Read @TType */ ttype_encoding = *p; @@ -691,10 +713,12 @@ decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 while (p < action_table) { int block_start_offset, block_size, landing_pad, action_offset; - block_start_offset = ((guint32*)p) [0]; - block_size = ((guint32*)p) [1]; - landing_pad = ((guint32*)p) [2]; - p += 3 * sizeof (guint32); + block_start_offset = read32 (p); + p += sizeof (gint32); + block_size = read32 (p); + p += sizeof (gint32); + landing_pad = read32 (p); + p += sizeof (gint32); action_offset = decode_uleb128 (p, &p); /* landing_pad == 0 means the region has no landing pad */ @@ -716,21 +740,46 @@ decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 int block_start_offset, block_size, landing_pad, action_offset, type_offset; guint8 *action, *tinfo; - block_start_offset = ((guint32*)p) [0]; - block_size = ((guint32*)p) [1]; - landing_pad = ((guint32*)p) [2]; - p += 3 * sizeof (guint32); + block_start_offset = read32 (p); + p += sizeof (gint32); + block_size = read32 (p); + p += sizeof (gint32); + landing_pad = read32 (p); + p += sizeof (gint32); action_offset = decode_uleb128 (p, &p); + if (!action_offset) + continue; + action = action_table + action_offset - 1; type_offset = decode_sleb128 (action, &action); - g_assert (ttype_encoding == DW_EH_PE_absptr); - tinfo = *(gpointer*)(ttype - (type_offset * sizeof (gpointer))); if (landing_pad) { //printf ("BLOCK: %p-%p %p, %d\n", code + block_start_offset, code + block_start_offset + block_size, code + landing_pad, action_offset); + g_assert (ttype_offset); + + if (ttype_encoding == DW_EH_PE_absptr) { + guint8 *ttype_entry = (ttype - (type_offset * sizeof (gpointer))); + tinfo = *(gpointer*)ttype_entry; + } else if (ttype_encoding == (DW_EH_PE_indirect | DW_EH_PE_pcrel | DW_EH_PE_sdata4)) { + guint8 *ttype_entry = (ttype - (type_offset * 4)); + gint32 offset = *(gint32*)ttype_entry; + guint8 *stub = ttype_entry + offset; + tinfo = *(gpointer*)stub; + } else if (ttype_encoding == (DW_EH_PE_pcrel | DW_EH_PE_sdata4)) { + guint8 *ttype_entry = (ttype - (type_offset * 4)); + gint32 offset = *(gint32*)ttype_entry; + tinfo = ttype_entry + offset; + } else if (ttype_encoding == DW_EH_PE_udata4) { + /* Embedded directly */ + guint8 *ttype_entry = (ttype - (type_offset * 4)); + tinfo = ttype_entry; + } else { + g_assert_not_reached (); + } + if (ex_info) { if (*type_info) (*type_info) [i] = tinfo; @@ -754,19 +803,24 @@ decode_lsda (guint8 *lsda, guint8 *code, MonoJitExceptionInfo **ex_info, guint32 * LSDA. */ guint8* -mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info) +mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJitExceptionInfo **ex_info, guint32 *ex_info_len, gpointer **type_info, int *this_reg, int *this_offset) { - guint8 *p, *cie, *fde_current, *fde_aug, *code, *fde_cfi, *cie_cfi; + guint8 *p, *cie, *fde_current, *fde_aug = NULL, *code, *fde_cfi, *cie_cfi; gint32 fde_len, cie_offset, pc_begin, pc_range, aug_len, fde_data_len; gint32 cie_len, cie_id, cie_version, code_align, data_align, return_reg; gint32 i, cie_aug_len, buf_len; char *cie_aug_str; guint8 *buf; + gboolean has_fde_augmentation = FALSE; /* * http://refspecs.freestandards.org/LSB_3.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html */ + *type_info = NULL; + *this_reg = -1; + *this_offset = -1; + /* Decode FDE */ p = fde; @@ -795,31 +849,38 @@ mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJi data_align = decode_sleb128 (p, &p); return_reg = decode_uleb128 (p, &p); if (strstr (cie_aug_str, "z")) { - cie_aug_len = decode_uleb128 (p, &p); + guint8 *cie_aug; + guint32 p_encoding; - g_assert (!strcmp (cie_aug_str, "zR") || !strcmp (cie_aug_str, "zPLR")); - - /* Check that the augmention is what we expect */ - if (!strcmp (cie_aug_str, "zPLR")) { - guint8 *cie_aug = p; - guint32 p_encoding; - - /* P */ - p_encoding = *p; - p ++; - read_encoded_val (p_encoding, p, &p); + cie_aug_len = decode_uleb128 (p, &p); - /* L */ - g_assert (*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)); - p ++; - /* R */ - g_assert (*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)); - p ++; + has_fde_augmentation = TRUE; - g_assert (p - cie_aug == cie_aug_len); - - p = cie_aug; + cie_aug = p; + for (i = 0; cie_aug_str [i] != '\0'; ++i) { + switch (cie_aug_str [i]) { + case 'z': + break; + case 'P': + p_encoding = *p; + p ++; + read_encoded_val (p_encoding, p, &p); + break; + case 'L': + g_assert ((*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)) || (*p == (DW_EH_PE_sdata8|DW_EH_PE_pcrel))); + p ++; + break; + case 'R': + g_assert (*p == (DW_EH_PE_sdata4|DW_EH_PE_pcrel)); + p ++; + break; + default: + g_assert_not_reached (); + break; + } } + + p = cie_aug; p += cie_aug_len; } cie_cfi = p; @@ -832,9 +893,13 @@ mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJi p += 4; pc_range = *(guint32*)p; p += 4; - aug_len = decode_uleb128 (p, &p); - fde_aug = p; - p += aug_len; + if (has_fde_augmentation) { + aug_len = decode_uleb128 (p, &p); + fde_aug = p; + p += aug_len; + } else { + aug_len = 0; + } fde_cfi = p; fde_data_len = fde + 4 + fde_len - p; @@ -851,21 +916,20 @@ mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJi gint32 lsda_offset; guint8 *lsda; - /* - * For some reason, this is 8 bytes long, even through it only includes - * the offset to the LSDA which is encoded as an sdata4. - */ - g_assert (aug_len == 8); /* sdata|pcrel encoding */ - lsda_offset = *(gint32*)fde_aug; + if (aug_len == 4) + lsda_offset = read32 (fde_aug); + else if (aug_len == 8) + lsda_offset = *(gint64*)fde_aug; + else + g_assert_not_reached (); if (lsda_offset != 0) { - lsda = fde_aug + *(gint32*)fde_aug; + lsda = fde_aug + lsda_offset; - decode_lsda (lsda, code, ex_info, ex_info_len, type_info); + decode_lsda (lsda, code, ex_info, ex_info_len, type_info, this_reg, this_offset); } } - /* Make sure the FDE uses the same constants as we do */ g_assert (code_align == 1); g_assert (data_align == DWARF_DATA_ALIGN); @@ -900,3 +964,97 @@ mono_unwind_decode_fde (guint8 *fde, guint32 *out_len, guint32 *code_len, MonoJi return g_realloc (buf, i); } + +/* + * mono_unwind_decode_mono_fde: + * + * Decode an FDE entry in the LLVM emitted mono EH frame. + * info->ex_info is set to a malloc-ed array of MonoJitExceptionInfo structures, + * only try_start, try_end and handler_start is set. + * info->type_info is set to a malloc-ed array containing the ttype table from the + * LSDA. + */ +void +mono_unwind_decode_llvm_mono_fde (guint8 *fde, int fde_len, guint8 *cie, guint8 *code, MonoLLVMFDEInfo *res) +{ + guint8 *p, *fde_aug, *cie_cfi, *fde_cfi, *buf; + int has_aug, aug_len, cie_cfi_len, fde_cfi_len; + gint32 code_align, data_align, return_reg, pers_encoding; + + memset (res, 0, sizeof (*res)); + res->this_reg = -1; + res->this_offset = -1; + + /* fde points to data emitted by LLVM in DwarfException::EmitMonoEHFrame () */ + p = fde; + has_aug = *p; + p ++; + if (has_aug) { + aug_len = read32 (p); + p += 4; + } else { + aug_len = 0; + } + fde_aug = p; + p += aug_len; + fde_cfi = p; + + if (has_aug) { + guint8 *lsda; + + /* The LSDA is embedded directly into the FDE */ + lsda = fde_aug; + + decode_lsda (lsda, code, &res->ex_info, &res->ex_info_len, &res->type_info, &res->this_reg, &res->this_offset); + } + + /* Decode CIE */ + p = cie; + code_align = decode_uleb128 (p, &p); + data_align = decode_sleb128 (p, &p); + return_reg = decode_uleb128 (p, &p); + pers_encoding = *p; + p ++; + if (pers_encoding != DW_EH_PE_omit) + read_encoded_val (pers_encoding, p, &p); + + cie_cfi = p; + + /* Make sure the FDE uses the same constants as we do */ + g_assert (code_align == 1); + g_assert (data_align == DWARF_DATA_ALIGN); + g_assert (return_reg == DWARF_PC_REG); + + /* Compute size of CIE unwind info it is DW_CFA_nop terminated */ + p = cie_cfi; + while (TRUE) { + if (*p == DW_CFA_nop) + break; + else + decode_cie_op (p, &p); + } + cie_cfi_len = p - cie_cfi; + fde_cfi_len = (fde + fde_len - fde_cfi); + + buf = g_malloc0 (cie_cfi_len + fde_cfi_len); + memcpy (buf, cie_cfi, cie_cfi_len); + memcpy (buf + cie_cfi_len, fde_cfi, fde_cfi_len); + + res->unw_info_len = cie_cfi_len + fde_cfi_len; + res->unw_info = buf; +} + +/* + * mono_unwind_get_cie_program: + * + * Get the unwind bytecode for the DWARF CIE. + */ +GSList* +mono_unwind_get_cie_program (void) +{ +#if defined(TARGET_AMD64) || defined(TARGET_X86) || defined(TARGET_POWERPC) + return mono_arch_get_cie_program (); +#else + return NULL; +#endif +}