diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 50482cd38f3..be345a47f10 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,60 @@ +2001-05-16 Richard Henderson + + * except.c (eh_data_format_name): Move to ... + * dwarf2asm.c: ... here. Use designated initializers if available. + (dw2_asm_output_encoded_addr_rtx): Accept varargs commentary. + * dwarf2asm.h: Update declarations. + * dwarf2out.c (output_cfi) [DW_CFA_set_loc]: If for_eh, mind + ASM_PREFERRED_EH_DATA_FORMAT. + (output_call_frame_info): Likewise. Use 'L' augmentation for + the LSDA encoding. + + * unwind-dw2-fde.h (struct fde_vector): New. + (struct old_object): Rename from struct object. + (struct object): New. + (__register_frame_info_bases): Declare. + (__register_frame_info_table_bases): Declare. + (struct dwarf_fde): Remove explicit pc_begin/pc_range members. + * unwind-dw2-fde.c (objects): Remove. + (unseen_objects, seen_objects): New. + (__register_frame_info_bases): New. + (__register_frame_info): Use it. + (__register_frame_info_table_bases): New. + (__register_frame_info_table): Use it. + (__deregister_frame_info): Rewrite for changed object struct. + (base_from_object, get_cie_encoding, get_fde_encoding): New. + (fde_unencoded_compare): Rename from fde_compare; uninline. + (fde_single_encoding_compare, fde_mixed_encoding_compare): New. + (start_fde_sort): Adjust for new definition of fde_vector. + (fde_insert): Likewise. + (end_fde_sort): Likewise. Select comparison function based + on properties of the object. + (fde_split): Take object and fde_compare_t arguments. + (frame_heapsort, fde_merge): Likewise. + (classify_object_over_fdes): Rename from count_fdes. Handle + encoded pointers. Collect encoding, mixed_encoding, and pc_begin + for the object. + (add_fdes): Handle encoded pointers. + (init_object): Rename from frame_init. Update for new struct object. + (linear_search_fdes): Rename from search_fdes. Handle encoded + pointers. + (binary_search_unencoded_fdes): Broken out from _Unwind_Find_FDE. + (binary_search_single_encoding_fdes): New. + (binary_search_mixed_encoding_fdes): New. + (search_object): New. + (_Unwind_Find_FDE): Update for new struct object. Fill in + the dwarf_eh_bases. + * unwind-dw2.c: Include unwind-pe.h. Constify all pointers + iterating over EH data. + (_Unwind_FrameState): Remove saw_lsda, addr_encoding. Add + fde_encoding, lsda_encoding. + (read_uleb128, read_sleb128): Remove. + (read_encoded_pointer): Remove. All callers use read_encoded_value. + (extract_cie_info): Set lsda_encoding from 'L' augmentation. + (uw_frame_state_for): Don't set bases.func. Handle encoded fde + pointers. + * unwind-pe.h: Add "struct" to _Unwind_Context references. + 2001-05-16 Neil Booth * cppexp.c (lex): Use NODE_NAME and NODE_LEN. diff --git a/gcc/dwarf2asm.c b/gcc/dwarf2asm.c index a18607aaf82..eff9a77a509 100644 --- a/gcc/dwarf2asm.c +++ b/gcc/dwarf2asm.c @@ -470,6 +470,152 @@ size_of_encoded_value (encoding) abort (); } +/* Yield a name for a given pointer encoding. */ + +const char * +eh_data_format_name (format) + int format; +{ +#if HAVE_DESIGNATED_INITIALIZERS +#define S(p, v) [p] = v, +#else +#define S(p, v) case p: return v; +#endif + +#if HAVE_DESIGNATED_INITIALIZERS + __extension__ static const char * const format_names[256] = { +#else + switch (format) { +#endif + + S(DW_EH_PE_absptr, "absolute") + S(DW_EH_PE_omit, "omit") + + S(DW_EH_PE_uleb128, "uleb128") + S(DW_EH_PE_udata2, "udata2") + S(DW_EH_PE_udata4, "udata4") + S(DW_EH_PE_udata8, "udata8") + S(DW_EH_PE_sleb128, "sleb128") + S(DW_EH_PE_sdata2, "sdata2") + S(DW_EH_PE_sdata4, "sdata4") + S(DW_EH_PE_sdata8, "sdata8") + + S(DW_EH_PE_uleb128 | DW_EH_PE_pcrel, "pcrel uleb128") + S(DW_EH_PE_udata2 | DW_EH_PE_pcrel, "pcrel udata2") + S(DW_EH_PE_udata4 | DW_EH_PE_pcrel, "pcrel udata4") + S(DW_EH_PE_udata8 | DW_EH_PE_pcrel, "pcrel udata8") + S(DW_EH_PE_sleb128 | DW_EH_PE_pcrel, "pcrel sleb128") + S(DW_EH_PE_sdata2 | DW_EH_PE_pcrel, "pcrel sdata2") + S(DW_EH_PE_sdata4 | DW_EH_PE_pcrel, "pcrel sdata4") + S(DW_EH_PE_sdata8 | DW_EH_PE_pcrel, "pcrel sdata8") + + S(DW_EH_PE_uleb128 | DW_EH_PE_textrel, "textrel uleb128") + S(DW_EH_PE_udata2 | DW_EH_PE_textrel, "textrel udata2") + S(DW_EH_PE_udata4 | DW_EH_PE_textrel, "textrel udata4") + S(DW_EH_PE_udata8 | DW_EH_PE_textrel, "textrel udata8") + S(DW_EH_PE_sleb128 | DW_EH_PE_textrel, "textrel sleb128") + S(DW_EH_PE_sdata2 | DW_EH_PE_textrel, "textrel sdata2") + S(DW_EH_PE_sdata4 | DW_EH_PE_textrel, "textrel sdata4") + S(DW_EH_PE_sdata8 | DW_EH_PE_textrel, "textrel sdata8") + + S(DW_EH_PE_uleb128 | DW_EH_PE_datarel, "datarel uleb128") + S(DW_EH_PE_udata2 | DW_EH_PE_datarel, "datarel udata2") + S(DW_EH_PE_udata4 | DW_EH_PE_datarel, "datarel udata4") + S(DW_EH_PE_udata8 | DW_EH_PE_datarel, "datarel udata8") + S(DW_EH_PE_sleb128 | DW_EH_PE_datarel, "datarel sleb128") + S(DW_EH_PE_sdata2 | DW_EH_PE_datarel, "datarel sdata2") + S(DW_EH_PE_sdata4 | DW_EH_PE_datarel, "datarel sdata4") + S(DW_EH_PE_sdata8 | DW_EH_PE_datarel, "datarel sdata8") + + S(DW_EH_PE_uleb128 | DW_EH_PE_funcrel, "funcrel uleb128") + S(DW_EH_PE_udata2 | DW_EH_PE_funcrel, "funcrel udata2") + S(DW_EH_PE_udata4 | DW_EH_PE_funcrel, "funcrel udata4") + S(DW_EH_PE_udata8 | DW_EH_PE_funcrel, "funcrel udata8") + S(DW_EH_PE_sleb128 | DW_EH_PE_funcrel, "funcrel sleb128") + S(DW_EH_PE_sdata2 | DW_EH_PE_funcrel, "funcrel sdata2") + S(DW_EH_PE_sdata4 | DW_EH_PE_funcrel, "funcrel sdata4") + S(DW_EH_PE_sdata8 | DW_EH_PE_funcrel, "funcrel sdata8") + + S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel, + "indirect pcrel uleb128") + S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel, + "indirect pcrel udata2") + S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel, + "indirect pcrel udata4") + S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel, + "indirect pcrel udata8") + S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel, + "indirect pcrel sleb128") + S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel, + "indirect pcrel sdata2") + S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel, + "indirect pcrel sdata4") + S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel, + "indirect pcrel sdata8") + + S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel, + "indirect textrel uleb128") + S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel, + "indirect textrel udata2") + S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel, + "indirect textrel udata4") + S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel, + "indirect textrel udata8") + S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel, + "indirect textrel sleb128") + S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel, + "indirect textrel sdata2") + S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel, + "indirect textrel sdata4") + S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel, + "indirect textrel sdata8") + + S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel, + "indirect datarel uleb128") + S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel, + "indirect datarel udata2") + S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel, + "indirect datarel udata4") + S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel, + "indirect datarel udata8") + S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel, + "indirect datarel sleb128") + S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel, + "indirect datarel sdata2") + S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel, + "indirect datarel sdata4") + S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel, + "indirect datarel sdata8") + + S(DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel, + "indirect funcrel uleb128") + S(DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel, + "indirect funcrel udata2") + S(DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel, + "indirect funcrel udata4") + S(DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel, + "indirect funcrel udata8") + S(DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel, + "indirect funcrel sleb128") + S(DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel, + "indirect funcrel sdata2") + S(DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel, + "indirect funcrel sdata4") + S(DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel, + "indirect funcrel sdata8") + +#if HAVE_DESIGNATED_INITIALIZERS + }; + + if (format < 0 || format > 0xff || format_names[format] == NULL) + abort (); + return format_names[format]; +#else + } + abort (); +#endif +} + /* Output an unsigned LEB128 quantity. */ void @@ -682,6 +828,11 @@ static int dw2_output_indirect_constant_1 PARAMS ((splay_tree_node, void *)); static splay_tree indirect_pool; +/* Put X, a SYMBOL_REF, in memory. Return a SYMBOL_REF to the allocated + memory. Differs from force_const_mem in that a single pool is used for + the entire unit of translation, and the memory is not guaranteed to be + "near" the function in any interesting sense. */ + static rtx dw2_force_const_mem (x) rtx x; @@ -718,6 +869,9 @@ dw2_force_const_mem (x) return gen_rtx_SYMBOL_REF (Pmode, const_sym); } +/* A helper function for dw2_output_indirect_constants called through + splay_tree_foreach. Emit one queued constant to memory. */ + static int dw2_output_indirect_constant_1 (node, data) splay_tree_node node; @@ -736,6 +890,8 @@ dw2_output_indirect_constant_1 (node, data) return 0; } +/* Emit the constants queued through dw2_force_const_mem. */ + void dw2_output_indirect_constants () { @@ -754,97 +910,104 @@ dw2_output_indirect_constants () splay_tree_foreach (indirect_pool, dw2_output_indirect_constant_1, NULL); } +/* Like dw2_asm_output_addr_rtx, but encode the pointer as directed. */ + void -dw2_asm_output_encoded_addr_rtx (encoding, addr) - int encoding; - rtx addr; +dw2_asm_output_encoded_addr_rtx VPARAMS ((int encoding, + rtx addr, + const char *comment, ...)) { +#ifndef ANSI_PROTOTYPES + int encoding; + rtx addr; + const char *comment; +#endif + va_list ap; int size; - switch (encoding & 0x07) - { - case DW_EH_PE_absptr: - size = POINTER_SIZE / BITS_PER_UNIT; - break; - case DW_EH_PE_udata2: - size = 2; - break; - case DW_EH_PE_udata4: - size = 4; - break; - case DW_EH_PE_udata8: - size = 8; - break; - default: - abort (); - } + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + encoding = va_arg (ap, int); + addr = va_arg (ap, rtx); + comment = va_arg (ap, const char *); +#endif + + size = size_of_encoded_value (encoding); /* NULL is _always_ represented as a plain zero. */ if (addr == const0_rtx) + assemble_integer (addr, size, 1); + else { - assemble_integer (addr, size, 1); - return; - } - - restart: - - /* Allow the target first crack at emitting this. Some of the - special relocations require special directives instead of - just ".4byte" or whatever. */ + restart: + /* Allow the target first crack at emitting this. Some of the + special relocations require special directives instead of + just ".4byte" or whatever. */ #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX - ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX(asm_out_file, encoding, size, addr, done); + ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX (asm_out_file, encoding, size, + addr, done); #endif - /* Indirection is used to get dynamic relocations out of a read-only - section. */ - if (encoding & DW_EH_PE_indirect) - { - /* It is very tempting to use force_const_mem so that we share data - with the normal constant pool. However, we've already emitted - the constant pool for this function. Moreover, we'd like to share - these constants across the entire unit of translation, or better, - across the entire application (or DSO). */ - addr = dw2_force_const_mem (addr); - encoding &= ~DW_EH_PE_indirect; - goto restart; - } + /* Indirection is used to get dynamic relocations out of a + read-only section. */ + if (encoding & DW_EH_PE_indirect) + { + /* It is very tempting to use force_const_mem so that we share data + with the normal constant pool. However, we've already emitted + the constant pool for this function. Moreover, we'd like to + share these constants across the entire unit of translation, + or better, across the entire application (or DSO). */ + addr = dw2_force_const_mem (addr); + encoding &= ~DW_EH_PE_indirect; + goto restart; + } - switch (encoding & 0xF0) - { - case DW_EH_PE_absptr: + switch (encoding & 0xF0) + { + case DW_EH_PE_absptr: #ifdef UNALIGNED_INT_ASM_OP - fputs (unaligned_integer_asm_op (size), asm_out_file); - output_addr_const (asm_out_file, addr); + fputs (unaligned_integer_asm_op (size), asm_out_file); + output_addr_const (asm_out_file, addr); #else - assemble_integer (addr, size, 1); + assemble_integer (addr, size, 1); #endif - break; + break; - case DW_EH_PE_pcrel: - if (GET_CODE (addr) != SYMBOL_REF) - abort (); + case DW_EH_PE_pcrel: + if (GET_CODE (addr) != SYMBOL_REF) + abort (); #ifdef ASM_OUTPUT_DWARF_PCREL - ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0)); + ASM_OUTPUT_DWARF_PCREL (asm_out_file, size, XSTR (addr, 0)); #else #ifdef UNALIGNED_INT_ASM_OP - fputs (unaligned_integer_asm_op (size), asm_out_file); - assemble_name (asm_out_file, XSTR (addr, 0)); - fputc ('-', asm_out_file); - fputc ('.', asm_out_file); + fputs (unaligned_integer_asm_op (size), asm_out_file); + assemble_name (asm_out_file, XSTR (addr, 0)); + fputc ('-', asm_out_file); + fputc ('.', asm_out_file); #else - abort (); + abort (); #endif #endif - break; + break; - default: - /* Other encodings should have been handled by - ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */ - abort (); - } + default: + /* Other encodings should have been handled by + ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX. */ + abort (); + } #ifdef ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX - done: + done:; #endif + } + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } fputc ('\n', asm_out_file); + + va_end (ap); } diff --git a/gcc/dwarf2asm.h b/gcc/dwarf2asm.h index 7f3baed0816..fb548b2cb89 100644 --- a/gcc/dwarf2asm.h +++ b/gcc/dwarf2asm.h @@ -48,7 +48,9 @@ extern void dw2_asm_output_addr_rtx PARAMS ((int, rtx, const char *, ...)) /* ATTRIBUTE_PRINTF_3 */; -extern void dw2_asm_output_encoded_addr_rtx PARAMS ((int, rtx)); +extern void dw2_asm_output_encoded_addr_rtx PARAMS ((int, rtx, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; extern void dw2_asm_output_nstring PARAMS ((const char *, size_t, const char *, ...)) @@ -73,5 +75,6 @@ extern void dw2_asm_output_delta_sleb128 PARAMS ((const char *, const char *, extern int size_of_uleb128 PARAMS ((unsigned HOST_WIDE_INT)); extern int size_of_sleb128 PARAMS ((HOST_WIDE_INT)); extern int size_of_encoded_value PARAMS ((int)); +extern const char *eh_data_format_name PARAMS ((int)); extern void dw2_output_indirect_constants PARAMS ((void)); diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index db839323df8..570c87a9dd9 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -1649,8 +1649,14 @@ output_cfi (cfi, fde, for_eh) switch (cfi->dw_cfi_opc) { case DW_CFA_set_loc: - dw2_asm_output_addr ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); + if (for_eh) + dw2_asm_output_encoded_addr_rtx ( + ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0), + gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr), + NULL); + else + dw2_asm_output_addr (DWARF2_ADDR_SIZE, + cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); break; case DW_CFA_advance_loc1: dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, @@ -1717,6 +1723,10 @@ output_call_frame_info (for_eh) char l1[20], l2[20]; int any_lsda_needed = 0; char augmentation[6]; + int augmentation_size; + int fde_encoding = DW_EH_PE_absptr; + int per_encoding = DW_EH_PE_absptr; + int lsda_encoding = DW_EH_PE_absptr; /* If we don't have any functions we'll want to unwind out of, don't emit any EH unwind information. */ @@ -1770,20 +1780,46 @@ output_call_frame_info (for_eh) dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); augmentation[0] = 0; + augmentation_size = 0; if (for_eh) { + char *p; + /* Augmentation: z Indicates that a uleb128 is present to size the augmentation section. - R Indicates a pointer encoding for CIE and FDE pointers. - P Indicates the presence of a language personality - routine in the CIE augmentation and an LSDA in the - FDE augmentation. */ + L Indicates the encoding (and thus presence) of + an LSDA pointer in the FDE augmentation. + R Indicates a non-default pointer encoding for + FDE code pointers. + P Indicates the presence of an encoding + language + personality routine in the CIE augmentation. */ - /* ??? Handle pointer encodings. */ + fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0); + per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1); + lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0); + p = augmentation + 1; + if (eh_personality_libfunc) + { + *p++ = 'P'; + augmentation_size += 1 + size_of_encoded_value (per_encoding); + } if (any_lsda_needed) - strcpy (augmentation, "zP"); + { + *p++ = 'L'; + augmentation_size += 1; + } + if (fde_encoding != DW_EH_PE_absptr) + { + *p++ = 'R'; + augmentation_size += 1; + } + if (p > augmentation + 1) + { + augmentation[0] = 'z'; + *p = '\0'; + } } dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation"); @@ -1796,12 +1832,20 @@ output_call_frame_info (for_eh) if (augmentation[0]) { - dw2_asm_output_data_uleb128 (PTR_SIZE, "Augmentation size"); + dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size"); if (eh_personality_libfunc) - dw2_asm_output_addr_rtx (PTR_SIZE, eh_personality_libfunc, - "Personality"); - else - dw2_asm_output_data (PTR_SIZE, 0, "Personality (none)"); + { + dw2_asm_output_data (1, per_encoding, "Personality (%s)", + eh_data_format_name (per_encoding)); + dw2_asm_output_encoded_addr_rtx (per_encoding, + eh_personality_libfunc, NULL); + } + if (any_lsda_needed) + dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)", + eh_data_format_name (lsda_encoding)); + if (fde_encoding != DW_EH_PE_absptr) + dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)", + eh_data_format_name (fde_encoding)); } for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) @@ -1843,29 +1887,45 @@ output_call_frame_info (for_eh) stripattributes (FRAME_SECTION), "FDE CIE offset"); - dw2_asm_output_addr ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - fde->dw_fde_begin, - "FDE initial location"); - - dw2_asm_output_delta ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - fde->dw_fde_end, - fde->dw_fde_begin, - "FDE address range"); + if (for_eh) + { + dw2_asm_output_encoded_addr_rtx (fde_encoding, + gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin), + "FDE initial location"); + dw2_asm_output_delta (size_of_encoded_value (fde_encoding), + fde->dw_fde_end, fde->dw_fde_begin, + "FDE address range"); + } + else + { + dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin, + "FDE initial location"); + dw2_asm_output_delta (DWARF2_ADDR_SIZE, + fde->dw_fde_end, fde->dw_fde_begin, + "FDE address range"); + } if (augmentation[0]) { - dw2_asm_output_data_uleb128 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - "Augmentation size"); - - if (fde->uses_eh_lsda) + if (any_lsda_needed) { - ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", fde->funcdef_number); - dw2_asm_output_offset ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - l1, "Language Specific Data Area"); + dw2_asm_output_data_uleb128 ( + size_of_encoded_value (lsda_encoding), "Augmentation size"); + + if (fde->uses_eh_lsda) + { + ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA", + fde->funcdef_number); + dw2_asm_output_encoded_addr_rtx ( + lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1), + "Language Specific Data Area"); + } + else + dw2_asm_output_data (size_of_encoded_value (lsda_encoding), + 0, "Language Specific Data Area (none)"); } else - dw2_asm_output_data ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE), - 0, "Language Specific Data Area (none)"); + dw2_asm_output_data_uleb128 (0, "Augmentation size"); } /* Loop through the Call Frame Instructions associated with @@ -1876,7 +1936,7 @@ output_call_frame_info (for_eh) /* Pad the FDE out to an address sized boundary. */ ASM_OUTPUT_ALIGN (asm_out_file, - floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); + floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE))); ASM_OUTPUT_LABEL (asm_out_file, l2); } diff --git a/gcc/except.c b/gcc/except.c index 3afb1edd4f0..b7771367149 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -330,7 +330,6 @@ static int add_call_site PARAMS ((rtx, int)); static void push_uleb128 PARAMS ((varray_type *, unsigned int)); static void push_sleb128 PARAMS ((varray_type *, int)); -static const char *eh_data_format_name PARAMS ((int)); #ifndef HAVE_AS_LEB128 static int dw2_size_of_call_site_table PARAMS ((void)); static int sjlj_size_of_call_site_table PARAMS ((void)); @@ -3367,133 +3366,6 @@ push_sleb128 (data_area, value) } -static const char * -eh_data_format_name (format) - int format; -{ - switch (format) - { - case DW_EH_PE_absptr: return "absolute"; - case DW_EH_PE_omit: return "omit"; - - case DW_EH_PE_uleb128: return "uleb128"; - case DW_EH_PE_udata2: return "udata2"; - case DW_EH_PE_udata4: return "udata4"; - case DW_EH_PE_udata8: return "udata8"; - case DW_EH_PE_sleb128: return "sleb128"; - case DW_EH_PE_sdata2: return "sdata2"; - case DW_EH_PE_sdata4: return "sdata4"; - case DW_EH_PE_sdata8: return "sdata8"; - - case DW_EH_PE_uleb128 | DW_EH_PE_pcrel: return "pcrel uleb128"; - case DW_EH_PE_udata2 | DW_EH_PE_pcrel: return "pcrel udata2"; - case DW_EH_PE_udata4 | DW_EH_PE_pcrel: return "pcrel udata4"; - case DW_EH_PE_udata8 | DW_EH_PE_pcrel: return "pcrel udata8"; - case DW_EH_PE_sleb128 | DW_EH_PE_pcrel: return "pcrel sleb128"; - case DW_EH_PE_sdata2 | DW_EH_PE_pcrel: return "pcrel sdata2"; - case DW_EH_PE_sdata4 | DW_EH_PE_pcrel: return "pcrel sdata4"; - case DW_EH_PE_sdata8 | DW_EH_PE_pcrel: return "pcrel sdata8"; - - case DW_EH_PE_uleb128 | DW_EH_PE_textrel: return "textrel uleb128"; - case DW_EH_PE_udata2 | DW_EH_PE_textrel: return "textrel udata2"; - case DW_EH_PE_udata4 | DW_EH_PE_textrel: return "textrel udata4"; - case DW_EH_PE_udata8 | DW_EH_PE_textrel: return "textrel udata8"; - case DW_EH_PE_sleb128 | DW_EH_PE_textrel: return "textrel sleb128"; - case DW_EH_PE_sdata2 | DW_EH_PE_textrel: return "textrel sdata2"; - case DW_EH_PE_sdata4 | DW_EH_PE_textrel: return "textrel sdata4"; - case DW_EH_PE_sdata8 | DW_EH_PE_textrel: return "textrel sdata8"; - - case DW_EH_PE_uleb128 | DW_EH_PE_datarel: return "datarel uleb128"; - case DW_EH_PE_udata2 | DW_EH_PE_datarel: return "datarel udata2"; - case DW_EH_PE_udata4 | DW_EH_PE_datarel: return "datarel udata4"; - case DW_EH_PE_udata8 | DW_EH_PE_datarel: return "datarel udata8"; - case DW_EH_PE_sleb128 | DW_EH_PE_datarel: return "datarel sleb128"; - case DW_EH_PE_sdata2 | DW_EH_PE_datarel: return "datarel sdata2"; - case DW_EH_PE_sdata4 | DW_EH_PE_datarel: return "datarel sdata4"; - case DW_EH_PE_sdata8 | DW_EH_PE_datarel: return "datarel sdata8"; - - case DW_EH_PE_uleb128 | DW_EH_PE_funcrel: return "funcrel uleb128"; - case DW_EH_PE_udata2 | DW_EH_PE_funcrel: return "funcrel udata2"; - case DW_EH_PE_udata4 | DW_EH_PE_funcrel: return "funcrel udata4"; - case DW_EH_PE_udata8 | DW_EH_PE_funcrel: return "funcrel udata8"; - case DW_EH_PE_sleb128 | DW_EH_PE_funcrel: return "funcrel sleb128"; - case DW_EH_PE_sdata2 | DW_EH_PE_funcrel: return "funcrel sdata2"; - case DW_EH_PE_sdata4 | DW_EH_PE_funcrel: return "funcrel sdata4"; - case DW_EH_PE_sdata8 | DW_EH_PE_funcrel: return "funcrel sdata8"; - - case DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_pcrel: - return "indirect pcrel uleb128"; - case DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_pcrel: - return "indirect pcrel udata2"; - case DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_pcrel: - return "indirect pcrel udata4"; - case DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_pcrel: - return "indirect pcrel udata8"; - case DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_pcrel: - return "indirect pcrel sleb128"; - case DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_pcrel: - return "indirect pcrel sdata2"; - case DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_pcrel: - return "indirect pcrel sdata4"; - case DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_pcrel: - return "indirect pcrel sdata8"; - - case DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_textrel: - return "indirect textrel uleb128"; - case DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_textrel: - return "indirect textrel udata2"; - case DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_textrel: - return "indirect textrel udata4"; - case DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_textrel: - return "indirect textrel udata8"; - case DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_textrel: - return "indirect textrel sleb128"; - case DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_textrel: - return "indirect textrel sdata2"; - case DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_textrel: - return "indirect textrel sdata4"; - case DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_textrel: - return "indirect textrel sdata8"; - - case DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_datarel: - return "indirect datarel uleb128"; - case DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_datarel: - return "indirect datarel udata2"; - case DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_datarel: - return "indirect datarel udata4"; - case DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_datarel: - return "indirect datarel udata8"; - case DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_datarel: - return "indirect datarel sleb128"; - case DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_datarel: - return "indirect datarel sdata2"; - case DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_datarel: - return "indirect datarel sdata4"; - case DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_datarel: - return "indirect datarel sdata8"; - - case DW_EH_PE_indirect | DW_EH_PE_uleb128 | DW_EH_PE_funcrel: - return "indirect funcrel uleb128"; - case DW_EH_PE_indirect | DW_EH_PE_udata2 | DW_EH_PE_funcrel: - return "indirect funcrel udata2"; - case DW_EH_PE_indirect | DW_EH_PE_udata4 | DW_EH_PE_funcrel: - return "indirect funcrel udata4"; - case DW_EH_PE_indirect | DW_EH_PE_udata8 | DW_EH_PE_funcrel: - return "indirect funcrel udata8"; - case DW_EH_PE_indirect | DW_EH_PE_sleb128 | DW_EH_PE_funcrel: - return "indirect funcrel sleb128"; - case DW_EH_PE_indirect | DW_EH_PE_sdata2 | DW_EH_PE_funcrel: - return "indirect funcrel sdata2"; - case DW_EH_PE_indirect | DW_EH_PE_sdata4 | DW_EH_PE_funcrel: - return "indirect funcrel sdata4"; - case DW_EH_PE_indirect | DW_EH_PE_sdata8 | DW_EH_PE_funcrel: - return "indirect funcrel sdata8"; - - default: - abort (); - } -} - #ifndef HAVE_AS_LEB128 static int dw2_size_of_call_site_table () @@ -3767,7 +3639,8 @@ output_function_exception_table () dw2_asm_output_encoded_addr_rtx (tt_format, expand_expr (type, NULL_RTX, VOIDmode, - EXPAND_INITIALIZER)); + EXPAND_INITIALIZER), + NULL); } #ifdef HAVE_AS_LEB128 diff --git a/gcc/unwind-dw2-fde.c b/gcc/unwind-dw2-fde.c index 7b6b44a5873..3a42f29a6ce 100644 --- a/gcc/unwind-dw2-fde.c +++ b/gcc/unwind-dw2-fde.c @@ -30,10 +30,18 @@ Boston, MA 02111-1307, USA. */ #include "tconfig.h" #include "tsystem.h" +#include "dwarf2.h" +#include "unwind.h" +#include "unwind-pe.h" #include "unwind-dw2-fde.h" #include "gthr.h" -static struct object *objects; +/* The unseen_objects list contains objects that have been registered + but not yet categorized in any way. The seen_objects list has had + it's pc_begin and count fields initialized at minimum, and is sorted + by decreasing value of pc_begin. */ +static struct object *unseen_objects; +static struct object *seen_objects; #ifdef __GTHREAD_MUTEX_INIT static __gthread_mutex_t object_mutex = __GTHREAD_MUTEX_INIT; @@ -61,22 +69,31 @@ init_object_mutex_once (void) /* Called from crtbegin.o to register the unwind info for an object. */ void -__register_frame_info (void *begin, struct object *ob) +__register_frame_info_bases (void *begin, struct object *ob, + void *tbase, void *dbase) { - ob->pc_begin = ob->pc_end = 0; - ob->fde_begin = begin; - ob->fde_array = 0; - ob->count = 0; + ob->pc_begin = (void *)-1; + ob->tbase = tbase; + ob->dbase = dbase; + ob->u.single = begin; + ob->s.i = 0; + ob->s.b.encoding = DW_EH_PE_omit; init_object_mutex_once (); __gthread_mutex_lock (&object_mutex); - ob->next = objects; - objects = ob; + ob->next = unseen_objects; + unseen_objects = ob; __gthread_mutex_unlock (&object_mutex); } +void +__register_frame_info (void *begin, struct object *ob) +{ + __register_frame_info_bases (begin, ob, 0, 0); +} + void __register_frame (void *begin) { @@ -89,22 +106,32 @@ __register_frame (void *begin) collect2. */ void -__register_frame_info_table (void *begin, struct object *ob) +__register_frame_info_table_bases (void *begin, struct object *ob, + void *tbase, void *dbase) { - ob->pc_begin = ob->pc_end = 0; - ob->fde_begin = begin; - ob->fde_array = begin; - ob->count = 0; + ob->pc_begin = (void *)-1; + ob->tbase = tbase; + ob->dbase = dbase; + ob->u.array = begin; + ob->s.i = 0; + ob->s.b.from_array = 1; + ob->s.b.encoding = DW_EH_PE_omit; init_object_mutex_once (); __gthread_mutex_lock (&object_mutex); - ob->next = objects; - objects = ob; + ob->next = unseen_objects; + unseen_objects = ob; __gthread_mutex_unlock (&object_mutex); } +void +__register_frame_info_table (void *begin, struct object *ob) +{ + __register_frame_info_table_bases (begin, ob, 0, 0); +} + void __register_frame_table (void *begin) { @@ -118,30 +145,46 @@ void * __deregister_frame_info (void *begin) { struct object **p; + struct object *ob = 0; init_object_mutex_once (); __gthread_mutex_lock (&object_mutex); - p = &objects; - while (*p) - { - if ((*p)->fde_begin == begin) - { - struct object *ob = *p; - *p = (*p)->next; + for (p = &unseen_objects; *p ; p = &(*p)->next) + if ((*p)->u.single == begin) + { + ob = *p; + *p = ob->next; + goto out; + } - /* If we've run init_frame for this object, free the FDE array. */ - if (ob->fde_array && ob->fde_array != begin) - free (ob->fde_array); - - __gthread_mutex_unlock (&object_mutex); - return (void *) ob; - } - p = &((*p)->next); - } + for (p = &seen_objects; *p ; p = &(*p)->next) + if ((*p)->s.b.sorted) + { + if ((*p)->u.sort->orig_data == begin) + { + ob = *p; + *p = ob->next; + free (ob->u.sort); + goto out; + } + } + else + { + if ((*p)->u.single == begin) + { + ob = *p; + *p = ob->next; + goto out; + } + } __gthread_mutex_unlock (&object_mutex); abort (); + + out: + __gthread_mutex_unlock (&object_mutex); + return (void *) ob; } void @@ -150,11 +193,120 @@ __deregister_frame (void *begin) free (__deregister_frame_info (begin)); } + +/* Like base_of_encoded_value, but take the base from a struct object + instead of an _Unwind_Context. */ + +static _Unwind_Ptr +base_from_object (unsigned char encoding, struct object *ob) +{ + if (encoding == DW_EH_PE_omit) + return 0; + + switch (encoding & 0x70) + { + case DW_EH_PE_absptr: + case DW_EH_PE_pcrel: + return 0; + + case DW_EH_PE_textrel: + return (_Unwind_Ptr) ob->tbase; + case DW_EH_PE_datarel: + return (_Unwind_Ptr) ob->dbase; + } + abort (); +} + +/* Return the FDE pointer encoding from the CIE. */ +/* ??? This is a subset of extract_cie_info from unwind-dw2.c. */ + +static int +get_cie_encoding (struct dwarf_cie *cie) +{ + const unsigned char *aug, *p; + _Unwind_Ptr dummy; + + aug = cie->augmentation; + if (aug[0] != 'z') + return DW_EH_PE_absptr; + + p = aug + strlen (aug) + 1; /* Skip the augmentation string. */ + p = read_uleb128 (p, &dummy); /* Skip code alignment. */ + p = read_sleb128 (p, &dummy); /* Skip data alignment. */ + p++; /* Skip return address column. */ + + aug++; /* Skip 'z' */ + p = read_uleb128 (p, &dummy); /* Skip augmentation length. */ + while (1) + { + /* This is what we're looking for. */ + if (*aug == 'R') + return *p; + /* Personality encoding and pointer. */ + else if (*aug == 'P') + p = read_encoded_value_with_base (*p & 0xF, 0, p + 1, &dummy); + /* LSDA encoding. */ + else if (*aug == 'L') + p++; + /* Otherwise end of string, or unknown augmentation. */ + else + return DW_EH_PE_absptr; + aug++; + } +} + +static inline int +get_fde_encoding (struct dwarf_fde *f) +{ + return get_cie_encoding (get_cie (f)); +} + /* Sorting an array of FDEs by address. (Ideally we would have the linker sort the FDEs so we don't have to do it at run time. But the linkers are not yet prepared for this.) */ +/* Comparison routines. Three variants of increasing complexity. */ + +static saddr +fde_unencoded_compare (struct object *ob __attribute__((unused)), + fde *x, fde *y) +{ + return *(saddr *)x->pc_begin - *(saddr *)y->pc_begin; +} + +static saddr +fde_single_encoding_compare (struct object *ob, fde *x, fde *y) +{ + _Unwind_Ptr base, x_ptr, y_ptr; + + base = base_from_object (ob->s.b.encoding, ob); + read_encoded_value_with_base (ob->s.b.encoding, base, x->pc_begin, &x_ptr); + read_encoded_value_with_base (ob->s.b.encoding, base, y->pc_begin, &y_ptr); + + return x_ptr - y_ptr; +} + +static saddr +fde_mixed_encoding_compare (struct object *ob, fde *x, fde *y) +{ + int x_encoding, y_encoding; + _Unwind_Ptr x_ptr, y_ptr; + + x_encoding = get_fde_encoding (x); + read_encoded_value_with_base (x_encoding, base_from_object (x_encoding, ob), + x->pc_begin, &x_ptr); + + y_encoding = get_fde_encoding (y); + read_encoded_value_with_base (y_encoding, base_from_object (y_encoding, ob), + y->pc_begin, &y_ptr); + + return x_ptr - y_ptr; +} + +typedef saddr (*fde_compare_t) (struct object *, fde *, fde *); + + /* This is a special mix of insertion sort and heap sort, optimized for the data sets that actually occur. They look like 101 102 103 127 128 105 108 110 190 111 115 119 125 160 126 129 130. @@ -166,41 +318,36 @@ __deregister_frame (void *begin) The worst-case total run time is O(N) + O(n log (n)), where N is the total number of FDEs and n is the number of erratic ones. */ -typedef struct fde_vector +struct fde_accumulator { - fde **array; - size_t count; -} fde_vector; - -typedef struct fde_accumulator -{ - fde_vector linear; - fde_vector erratic; -} fde_accumulator; - -static inline saddr -fde_compare (fde *x, fde *y) -{ - return (saddr)x->pc_begin - (saddr)y->pc_begin; -} + struct fde_vector *linear; + struct fde_vector *erratic; +}; static inline int -start_fde_sort (fde_accumulator *accu, size_t count) +start_fde_sort (struct fde_accumulator *accu, size_t count) { - accu->linear.array = count ? (fde **) malloc (sizeof (fde *) * count) : NULL; - accu->erratic.array = accu->linear.array ? - (fde **) malloc (sizeof (fde *) * count) : NULL; - accu->linear.count = 0; - accu->erratic.count = 0; - - return accu->linear.array != NULL; + size_t size; + if (! count) + return 0; + + size = sizeof (struct fde_vector) + sizeof (fde *) * count; + if ((accu->linear = (struct fde_vector *) malloc (size))) + { + accu->linear->count = 0; + if ((accu->erratic = (struct fde_vector *) malloc (size))) + accu->erratic->count = 0; + return 1; + } + else + return 0; } static inline void -fde_insert (fde_accumulator *accu, fde *this_fde) +fde_insert (struct fde_accumulator *accu, fde *this_fde) { - if (accu->linear.array) - accu->linear.array[accu->linear.count++] = this_fde; + if (accu->linear) + accu->linear->array[accu->linear->count++] = this_fde; } /* Split LINEAR into a linear sequence with low values and an erratic @@ -214,8 +361,10 @@ fde_insert (fde_accumulator *accu, fde *this_fde) the ERRATIC array during construction. A final pass iterates over the chain to determine what should be placed in the ERRATIC array, and what is the linear sequence. This overlay is safe from aliasing. */ + static inline void -fde_split (fde_vector *linear, fde_vector *erratic) +fde_split (struct object *ob, fde_compare_t fde_compare, + struct fde_vector *linear, struct fde_vector *erratic) { static fde *marker; size_t count = linear->count; @@ -233,7 +382,7 @@ fde_split (fde_vector *linear, fde_vector *erratic) fde **probe; for (probe = chain_end; - probe != &marker && fde_compare (linear->array[i], *probe) < 0; + probe != &marker && fde_compare (ob, linear->array[i], *probe) < 0; probe = chain_end) { chain_end = (fde **)erratic->array[probe - linear->array]; @@ -257,8 +406,10 @@ fde_split (fde_vector *linear, fde_vector *erratic) /* This is O(n log(n)). BSD/OS defines heapsort in stdlib.h, so we must use a name that does not conflict. */ -static inline void -frame_heapsort (fde_vector *erratic) + +static void +frame_heapsort (struct object *ob, fde_compare_t fde_compare, + struct fde_vector *erratic) { /* For a description of this algorithm, see: Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed., @@ -279,13 +430,13 @@ frame_heapsort (fde_vector *erratic) for (i = m; 2*i+1 < n; ) { if (2*i+2 < n - && fde_compare (a[2*i+2], a[2*i+1]) > 0 - && fde_compare (a[2*i+2], a[i]) > 0) + && fde_compare (ob, a[2*i+2], a[2*i+1]) > 0 + && fde_compare (ob, a[2*i+2], a[i]) > 0) { SWAP (a[i], a[2*i+2]); i = 2*i+2; } - else if (fde_compare (a[2*i+1], a[i]) > 0) + else if (fde_compare (ob, a[2*i+1], a[i]) > 0) { SWAP (a[i], a[2*i+1]); i = 2*i+1; @@ -302,13 +453,13 @@ frame_heapsort (fde_vector *erratic) for (i = 0; 2*i+1 < n; ) { if (2*i+2 < n - && fde_compare (a[2*i+2], a[2*i+1]) > 0 - && fde_compare (a[2*i+2], a[i]) > 0) + && fde_compare (ob, a[2*i+2], a[2*i+1]) > 0 + && fde_compare (ob, a[2*i+2], a[i]) > 0) { SWAP (a[i], a[2*i+2]); i = 2*i+2; } - else if (fde_compare (a[2*i+1], a[i]) > 0) + else if (fde_compare (ob, a[2*i+1], a[i]) > 0) { SWAP (a[i], a[2*i+1]); i = 2*i+1; @@ -321,8 +472,9 @@ frame_heapsort (fde_vector *erratic) } /* Merge V1 and V2, both sorted, and put the result into V1. */ -static void -fde_merge (fde_vector *v1, const fde_vector *v2) +static inline void +fde_merge (struct object *ob, fde_compare_t fde_compare, + struct fde_vector *v1, struct fde_vector *v2) { size_t i1, i2; fde * fde2; @@ -334,7 +486,7 @@ fde_merge (fde_vector *v1, const fde_vector *v2) do { i2--; fde2 = v2->array[i2]; - while (i1 > 0 && fde_compare (v1->array[i1-1], fde2) > 0) + while (i1 > 0 && fde_compare (ob, v1->array[i1-1], fde2) > 0) { v1->array[i1+i2] = v1->array[i1-1]; i1--; @@ -345,81 +497,154 @@ fde_merge (fde_vector *v1, const fde_vector *v2) } } -static fde ** -end_fde_sort (fde_accumulator *accu, size_t count) +static inline void +end_fde_sort (struct object *ob, struct fde_accumulator *accu, size_t count) { - if (accu->linear.array && accu->linear.count != count) + fde_compare_t fde_compare; + + if (accu->linear && accu->linear->count != count) abort (); - - if (accu->erratic.array) + + if (ob->s.b.mixed_encoding) + fde_compare = fde_mixed_encoding_compare; + else if (ob->s.b.encoding == DW_EH_PE_absptr) + fde_compare = fde_unencoded_compare; + else + fde_compare = fde_single_encoding_compare; + + if (accu->erratic) { - fde_split (&accu->linear, &accu->erratic); - if (accu->linear.count + accu->erratic.count != count) + fde_split (ob, fde_compare, accu->linear, accu->erratic); + if (accu->linear->count + accu->erratic->count != count) abort (); - frame_heapsort (&accu->erratic); - fde_merge (&accu->linear, &accu->erratic); - free (accu->erratic.array); + frame_heapsort (ob, fde_compare, accu->erratic); + fde_merge (ob, fde_compare, accu->linear, accu->erratic); + free (accu->erratic); } else { - /* We've not managed to malloc an erratic array, so heap sort in the - linear one. */ - frame_heapsort (&accu->linear); + /* We've not managed to malloc an erratic array, + so heap sort in the linear one. */ + frame_heapsort (ob, fde_compare, accu->linear); } - return accu->linear.array; } -static size_t -count_fdes (fde *this_fde) -{ - size_t count; +/* Update encoding, mixed_encoding, and pc_begin for OB for the + fde array beginning at THIS_FDE. Return the number of fdes + encountered along the way. */ - for (count = 0; this_fde->length != 0; this_fde = next_fde (this_fde)) - /* Skip CIEs and omitted link-once FDE entries. */ - if (this_fde->CIE_delta != 0 && this_fde->pc_begin != 0) - ++count; +static size_t +classify_object_over_fdes (struct object *ob, fde *this_fde) +{ + struct dwarf_cie *last_cie = 0; + size_t count = 0; + int encoding = DW_EH_PE_absptr; + _Unwind_Ptr base = 0; + + for (; this_fde->length != 0; this_fde = next_fde (this_fde)) + { + struct dwarf_cie *this_cie; + _Unwind_Ptr mask, pc_begin; + + /* Skip CIEs. */ + if (this_fde->CIE_delta == 0) + continue; + + /* Determine the encoding for this FDE. Note mixed encoded + objects for later. */ + this_cie = get_cie (this_fde); + if (this_cie != last_cie) + { + last_cie = this_cie; + encoding = get_cie_encoding (this_cie); + base = base_from_object (encoding, ob); + if (ob->s.b.encoding == DW_EH_PE_omit) + ob->s.b.encoding = encoding; + else if (ob->s.b.encoding != encoding) + ob->s.b.mixed_encoding = 1; + } + + read_encoded_value_with_base (encoding, base, this_fde->pc_begin, + &pc_begin); + + /* Take care to ignore link-once functions that were removed. + In these cases, the function address will be NULL, but if + the encoding is smaller than a pointer a true NULL may not + be representable. Assume 0 in the representable bits is NULL. */ + mask = size_of_encoded_value (encoding); + if (mask < sizeof (void *)) + mask = (1L << (mask << 3)) - 1; + else + mask = -1; + + if ((pc_begin & mask) == 0) + continue; + + count += 1; + if ((void *)pc_begin < ob->pc_begin) + ob->pc_begin = (void *)pc_begin; + } return count; } static void -add_fdes (fde *this_fde, fde_accumulator *accu, void **beg_ptr, void **end_ptr) +add_fdes (struct object *ob, struct fde_accumulator *accu, fde *this_fde) { - void *pc_begin = *beg_ptr; - void *pc_end = *end_ptr; + struct dwarf_cie *last_cie = 0; + int encoding = ob->s.b.encoding; + _Unwind_Ptr base = base_from_object (ob->s.b.encoding, ob); for (; this_fde->length != 0; this_fde = next_fde (this_fde)) { - /* Skip CIEs and linked once FDE entries. */ - if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0) - continue; + struct dwarf_cie *this_cie; + + /* Skip CIEs. */ + if (this_fde->CIE_delta == 0) + continue; + + if (ob->s.b.mixed_encoding) + { + /* Determine the encoding for this FDE. Note mixed encoded + objects for later. */ + this_cie = get_cie (this_fde); + if (this_cie != last_cie) + { + last_cie = this_cie; + encoding = get_cie_encoding (this_cie); + base = base_from_object (encoding, ob); + } + } + + if (encoding == DW_EH_PE_absptr) + { + if (*(_Unwind_Ptr *)this_fde->pc_begin == 0) + continue; + } + else + { + _Unwind_Ptr pc_begin, mask; + + read_encoded_value_with_base (encoding, base, this_fde->pc_begin, + &pc_begin); + + /* Take care to ignore link-once functions that were removed. + In these cases, the function address will be NULL, but if + the encoding is smaller than a pointer a true NULL may not + be representable. Assume 0 in the representable bits is NULL. */ + mask = size_of_encoded_value (encoding); + if (mask < sizeof (void *)) + mask = (1L << (mask << 3)) - 1; + else + mask = -1; + + if ((pc_begin & mask) == 0) + continue; + } fde_insert (accu, this_fde); - - if (this_fde->pc_begin < pc_begin) - pc_begin = this_fde->pc_begin; - if (this_fde->pc_begin + this_fde->pc_range > pc_end) - pc_end = this_fde->pc_begin + this_fde->pc_range; } - - *beg_ptr = pc_begin; - *end_ptr = pc_end; -} - -static fde * -search_fdes (fde *this_fde, void *pc) -{ - for (; this_fde->length != 0; this_fde = next_fde (this_fde)) - { - /* Skip CIEs and linked once FDE entries. */ - if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0) - continue; - - if ((uaddr)((char *)pc - (char *)this_fde->pc_begin) < this_fde->pc_range) - return this_fde; - } - return NULL; } /* Set up a sorted array of pointers to FDEs for a loaded object. We @@ -427,116 +652,317 @@ search_fdes (fde *this_fde, void *pc) be faster. We can be called multiple times, should we have failed to allocate a sorted fde array on a previous occasion. */ -static void -frame_init (struct object* ob) +static inline void +init_object (struct object* ob) { + struct fde_accumulator accu; size_t count; - fde_accumulator accu; - void *pc_begin, *pc_end; - fde **array; - if (ob->pc_begin) - count = ob->count; - else if (ob->fde_array) + count = ob->s.b.count; + if (count == 0) { - fde **p = ob->fde_array; - for (count = 0; *p; ++p) - count += count_fdes (*p); - } - else - count = count_fdes (ob->fde_begin); - ob->count = count; + if (ob->s.b.from_array) + { + fde **p = ob->u.array; + for (count = 0; *p; ++p) + count += classify_object_over_fdes (ob, *p); + } + else + count = classify_object_over_fdes (ob, ob->u.single); - if (!start_fde_sort (&accu, count) && ob->pc_begin) + /* The count field we have in the main struct object is somewhat + limited, but should suffice for virtually all cases. If the + counted value doesn't fit, re-write a zero. The worst that + happens is that we re-count next time -- admittedly non-trivial + in that this implies some 2M fdes, but at least we function. */ + ob->s.b.count = count; + if (ob->s.b.count != count) + ob->s.b.count = 0; + } + + if (!start_fde_sort (&accu, count)) return; - pc_begin = (void*)(uaddr)-1; - pc_end = 0; - - if (ob->fde_array) + if (ob->s.b.from_array) { - fde **p = ob->fde_array; - for (; *p; ++p) - add_fdes (*p, &accu, &pc_begin, &pc_end); + fde **p; + for (p = ob->u.array; *p; ++p) + add_fdes (ob, &accu, *p); } else - add_fdes (ob->fde_begin, &accu, &pc_begin, &pc_end); - array = end_fde_sort (&accu, count); - if (array) - ob->fde_array = array; - ob->pc_begin = pc_begin; - ob->pc_end = pc_end; + add_fdes (ob, &accu, ob->u.single); + + end_fde_sort (ob, &accu, count); + + /* Save the original fde pointer, since this is the key by which the + DSO will deregister the object. */ + accu.linear->orig_data = ob->u.single; + ob->u.sort = accu.linear; + + ob->s.b.sorted = 1; +} + +/* A linear search through a set of FDEs for the given PC. This is + used when there was insufficient memory to allocate and sort an + array. */ + +static fde * +linear_search_fdes (struct object *ob, fde *this_fde, void *pc) +{ + struct dwarf_cie *last_cie = 0; + int encoding = ob->s.b.encoding; + _Unwind_Ptr base = base_from_object (ob->s.b.encoding, ob); + + for (; this_fde->length != 0; this_fde = next_fde (this_fde)) + { + struct dwarf_cie *this_cie; + _Unwind_Ptr pc_begin, pc_range; + + /* Skip CIEs. */ + if (this_fde->CIE_delta == 0) + continue; + + if (ob->s.b.mixed_encoding) + { + /* Determine the encoding for this FDE. Note mixed encoded + objects for later. */ + this_cie = get_cie (this_fde); + if (this_cie != last_cie) + { + last_cie = this_cie; + encoding = get_cie_encoding (this_cie); + base = base_from_object (encoding, ob); + } + } + + if (encoding == DW_EH_PE_absptr) + { + pc_begin = ((_Unwind_Ptr *)this_fde->pc_begin)[0]; + pc_range = ((_Unwind_Ptr *)this_fde->pc_begin)[1]; + if (pc_begin == 0) + continue; + } + else + { + _Unwind_Ptr mask; + const char *p; + + p = read_encoded_value_with_base (encoding, base, + this_fde->pc_begin, &pc_begin); + read_encoded_value_with_base (encoding & 0x0F, 0, p, &pc_range); + + /* Take care to ignore link-once functions that were removed. + In these cases, the function address will be NULL, but if + the encoding is smaller than a pointer a true NULL may not + be representable. Assume 0 in the representable bits is NULL. */ + mask = size_of_encoded_value (encoding); + if (mask < sizeof (void *)) + mask = (1L << (mask << 3)) - 1; + else + mask = -1; + + if ((pc_begin & mask) == 0) + continue; + } + + if ((_Unwind_Ptr)pc - pc_begin < pc_range) + return this_fde; + } + + return NULL; +} + +/* Binary search for an FDE containing the given PC. Here are three + implementations of increasing complexity. */ + +static inline fde * +binary_search_unencoded_fdes (struct object *ob, void *pc) +{ + struct fde_vector *vec = ob->u.sort; + size_t lo, hi; + + for (lo = 0, hi = vec->count; lo < hi; ) + { + size_t i = (lo + hi) / 2; + fde *f = vec->array[i]; + void *pc_begin; + uaddr pc_range; + + pc_begin = ((void **)f->pc_begin)[0]; + pc_range = ((uaddr *)f->pc_begin)[1]; + + if (pc < pc_begin) + hi = i; + else if (pc >= pc_begin + pc_range) + lo = i + 1; + else + return f; + } + + return NULL; +} + +static inline fde * +binary_search_single_encoding_fdes (struct object *ob, void *pc) +{ + struct fde_vector *vec = ob->u.sort; + int encoding = ob->s.b.encoding; + _Unwind_Ptr base = base_from_object (encoding, ob); + size_t lo, hi; + + for (lo = 0, hi = vec->count; lo < hi; ) + { + size_t i = (lo + hi) / 2; + fde *f = vec->array[i]; + _Unwind_Ptr pc_begin, pc_range; + const char *p; + + p = read_encoded_value_with_base (encoding, base, f->pc_begin, + &pc_begin); + read_encoded_value_with_base (encoding & 0x0F, 0, p, &pc_range); + + if ((_Unwind_Ptr)pc < pc_begin) + hi = i; + else if ((_Unwind_Ptr)pc >= pc_begin + pc_range) + lo = i + 1; + else + return f; + } + + return NULL; +} + +static inline fde * +binary_search_mixed_encoding_fdes (struct object *ob, void *pc) +{ + struct fde_vector *vec = ob->u.sort; + size_t lo, hi; + + for (lo = 0, hi = vec->count; lo < hi; ) + { + size_t i = (lo + hi) / 2; + fde *f = vec->array[i]; + _Unwind_Ptr pc_begin, pc_range; + const char *p; + int encoding; + + encoding = get_fde_encoding (f); + p = read_encoded_value_with_base (encoding, + base_from_object (encoding, ob), + f->pc_begin, &pc_begin); + read_encoded_value_with_base (encoding & 0x0F, 0, p, &pc_range); + + if ((_Unwind_Ptr)pc < pc_begin) + hi = i; + else if ((_Unwind_Ptr)pc >= pc_begin + pc_range) + lo = i + 1; + else + return f; + } + + return NULL; +} + +static fde * +search_object (struct object* ob, void *pc) +{ + /* If the data hasn't been sorted, try to do this now. We may have + more memory available than last time we tried. */ + if (! ob->s.b.sorted) + { + init_object (ob); + + /* Despite the above comment, the normal reason to get here is + that we've not processed this object before. A quick range + check is in order. */ + if (pc < ob->pc_begin) + return NULL; + } + + if (ob->s.b.sorted) + { + if (ob->s.b.mixed_encoding) + return binary_search_mixed_encoding_fdes (ob, pc); + else if (ob->s.b.encoding == DW_EH_PE_absptr) + return binary_search_unencoded_fdes (ob, pc); + else + return binary_search_single_encoding_fdes (ob, pc); + } + else + { + /* Long slow labourious linear search, cos we've no memory. */ + if (ob->s.b.from_array) + { + fde **p; + for (p = ob->u.array; *p ; p++) + { + fde *f = linear_search_fdes (ob, *p, pc); + if (f) + return f; + } + return NULL; + } + else + return linear_search_fdes (ob, ob->u.single, pc); + } } fde * -_Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases ATTRIBUTE_UNUSED) +_Unwind_Find_FDE (void *pc, struct dwarf_eh_bases *bases) { struct object *ob; - size_t lo, hi; + fde *f = NULL; init_object_mutex_once (); __gthread_mutex_lock (&object_mutex); - /* Linear search through the objects, to find the one containing the pc. */ - for (ob = objects; ob; ob = ob->next) + /* Linear search through the classified objects, to find the one + containing the pc. Note that pc_begin is sorted decending, and + we expect objects to be non-overlapping. */ + for (ob = seen_objects; ob; ob = ob->next) + if (pc >= ob->pc_begin) + { + f = search_object (ob, pc); + if (f) + goto fini; + break; + } + + /* Classify and search the objects we've not yet processed. */ + while ((ob = unseen_objects)) { - if (ob->pc_begin == 0) - frame_init (ob); - if (pc >= ob->pc_begin && pc < ob->pc_end) - break; + struct object **p; + + unseen_objects = ob->next; + f = search_object (ob, pc); + + /* Insert the object into the classified list. */ + for (p = &seen_objects; *p ; p = &(*p)->next) + if ((*p)->pc_begin < ob->pc_begin) + break; + ob->next = *p; + *p = ob; + + if (f) + goto fini; } - if (ob == 0) + fini: + __gthread_mutex_unlock (&object_mutex); + + if (f) { - __gthread_mutex_unlock (&object_mutex); - return 0; + int encoding; + + bases->tbase = ob->tbase; + bases->dbase = ob->dbase; + + encoding = ob->s.b.encoding; + if (ob->s.b.mixed_encoding) + encoding = get_fde_encoding (f); + read_encoded_value_with_base (encoding, base_from_object (encoding, ob), + f->pc_begin, (_Unwind_Ptr *)&bases->func); } - if (!ob->fde_array || (void *)ob->fde_array == (void *)ob->fde_begin) - frame_init (ob); - - if (ob->fde_array && (void *)ob->fde_array != (void *)ob->fde_begin) - { - __gthread_mutex_unlock (&object_mutex); - - /* Standard binary search algorithm. */ - for (lo = 0, hi = ob->count; lo < hi; ) - { - size_t i = (lo + hi) / 2; - fde *f = ob->fde_array[i]; - - if (pc < f->pc_begin) - hi = i; - else if (pc >= f->pc_begin + f->pc_range) - lo = i + 1; - else - return f; - } - } - else - { - /* Long slow labourious linear search, cos we've no memory. */ - fde *f; - - if (ob->fde_array) - { - fde **p = ob->fde_array; - - do - { - f = search_fdes (*p, pc); - if (f) - break; - p++; - } - while (*p); - } - else - f = search_fdes (ob->fde_begin, pc); - - __gthread_mutex_unlock (&object_mutex); - return f; - } - - return 0; + return f; } diff --git a/gcc/unwind-dw2-fde.h b/gcc/unwind-dw2-fde.h index 83b519a48b9..efbded0fa99 100644 --- a/gcc/unwind-dw2-fde.h +++ b/gcc/unwind-dw2-fde.h @@ -29,15 +29,52 @@ the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -/* Describes data used to hold onto one shared object or object file. */ +struct fde_vector +{ + void *orig_data; + size_t count; + struct dwarf_fde *array[]; +}; + struct object +{ + void *pc_begin; + void *tbase; + void *dbase; + union { + struct dwarf_fde *single; + struct dwarf_fde **array; + struct fde_vector *sort; + } u; + + union { + struct { + unsigned long sorted : 1; + unsigned long from_array : 1; + unsigned long mixed_encoding : 1; + unsigned long encoding : 8; + /* ??? Wish there was an easy way to detect a 64-bit host here; + we've got 32 bits left to play with... */ + unsigned long count : 21; + } b; + size_t i; + } s; + + struct object *next; +}; + +/* This is the original definition of struct object. While the struct + itself was opaque to users, they did know how large it was, and + allocate one statically in crtbegin for each DSO. Keep this around + so that we're aware of the static size limitations for the new struct. */ +struct old_object { void *pc_begin; void *pc_end; struct dwarf_fde *fde_begin; struct dwarf_fde **fde_array; size_t count; - struct object *next; + struct old_object *next; }; struct dwarf_eh_bases @@ -48,8 +85,12 @@ struct dwarf_eh_bases }; +extern void __register_frame_info_bases (void *, struct object *, + void *, void *); extern void __register_frame_info (void *, struct object *); extern void __register_frame (void *); +extern void __register_frame_info_table_bases (void *, struct object *, + void *, void *); extern void __register_frame_info_table (void *, struct object *); extern void __register_frame_table (void *); extern void *__deregister_frame_info (void *); @@ -97,8 +138,7 @@ struct dwarf_fde { uword length; sword CIE_delta; - void * pc_begin; - uaddr pc_range; + unsigned char pc_begin[]; } __attribute__ ((packed, aligned (__alignof__ (void *)))); typedef struct dwarf_fde fde; diff --git a/gcc/unwind-dw2.c b/gcc/unwind-dw2.c index 6eb163d904b..20deb5721f9 100644 --- a/gcc/unwind-dw2.c +++ b/gcc/unwind-dw2.c @@ -22,6 +22,7 @@ #include "tsystem.h" #include "dwarf2.h" #include "unwind.h" +#include "unwind-pe.h" #include "unwind-dw2-fde.h" #include "gthr.h" @@ -69,7 +70,7 @@ typedef struct union { unsigned int reg; _Unwind_Sword offset; - unsigned char *exp; + const unsigned char *exp; } loc; enum { REG_UNSAVED, @@ -87,7 +88,7 @@ typedef struct location expression. */ _Unwind_Sword cfa_offset; _Unwind_Word cfa_reg; - unsigned char *cfa_exp; + const unsigned char *cfa_exp; enum { CFA_UNSET, CFA_REG_OFFSET, @@ -102,57 +103,11 @@ typedef struct signed int data_align; unsigned int code_align; unsigned char retaddr_column; - unsigned char addr_encoding; + unsigned char fde_encoding; + unsigned char lsda_encoding; unsigned char saw_z; - unsigned char saw_lsda; } _Unwind_FrameState; -/* Decode the unsigned LEB128 constant at BUF into the variable pointed to - by R, and return the new value of BUF. */ - -static unsigned char * -read_uleb128 (unsigned char *buf, _Unwind_Word *r) -{ - unsigned shift = 0; - _Unwind_Word result = 0; - - while (1) - { - unsigned char byte = *buf++; - result |= (byte & 0x7f) << shift; - if ((byte & 0x80) == 0) - break; - shift += 7; - } - *r = result; - return buf; -} - -/* Decode the signed LEB128 constant at BUF into the variable pointed to - by R, and return the new value of BUF. */ - -static unsigned char * -read_sleb128 (unsigned char *buf, _Unwind_Sword *r) -{ - unsigned shift = 0; - _Unwind_Sword result = 0; - unsigned char byte; - - while (1) - { - byte = *buf++; - result |= (byte & 0x7f) << shift; - shift += 7; - if ((byte & 0x80) == 0) - break; - } - if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0) - result |= - (1 << shift); - - *r = result; - return buf; -} - /* Read unaligned data from the instruction buffer. */ union unaligned @@ -167,107 +122,31 @@ union unaligned } __attribute__ ((packed)); static inline void * -read_pointer (void *p) { union unaligned *up = p; return up->p; } +read_pointer (const void *p) { const union unaligned *up = p; return up->p; } static inline int -read_1u (void *p) { return *(unsigned char *)p; } +read_1u (const void *p) { return *(const unsigned char *)p; } static inline int -read_1s (void *p) { return *(signed char *)p; } +read_1s (const void *p) { return *(const signed char *)p; } static inline int -read_2u (void *p) { union unaligned *up = p; return up->u2; } +read_2u (const void *p) { const union unaligned *up = p; return up->u2; } static inline int -read_2s (void *p) { union unaligned *up = p; return up->s2; } +read_2s (const void *p) { const union unaligned *up = p; return up->s2; } static inline unsigned int -read_4u (void *p) { union unaligned *up = p; return up->u4; } +read_4u (const void *p) { const union unaligned *up = p; return up->u4; } static inline int -read_4s (void *p) { union unaligned *up = p; return up->s4; } +read_4s (const void *p) { const union unaligned *up = p; return up->s4; } static inline unsigned long -read_8u (void *p) { union unaligned *up = p; return up->u8; } +read_8u (const void *p) { const union unaligned *up = p; return up->u8; } static inline unsigned long -read_8s (void *p) { union unaligned *up = p; return up->s8; } - -static unsigned char * -read_encoded_pointer (unsigned char *p, unsigned char encoding, - struct dwarf_eh_bases *bases, void **pptr) -{ - signed long val; - unsigned char *ret; - - switch (encoding & 0x0f) - { - case DW_EH_PE_absptr: - val = (_Unwind_Ptr) read_pointer (p); - ret = p + sizeof (void *); - break; - - case DW_EH_PE_uleb128: - ret = read_uleb128 (p, &val); - break; - case DW_EH_PE_sleb128: - ret = read_sleb128 (p, &val); - break; - - case DW_EH_PE_udata2: - val = read_2u (p); - ret = p + 2; - break; - case DW_EH_PE_udata4: - val = read_4u (p); - ret = p + 4; - break; - case DW_EH_PE_udata8: - val = read_8u (p); - ret = p + 8; - break; - - case DW_EH_PE_sdata2: - val = read_2s (p); - ret = p + 2; - break; - case DW_EH_PE_sdata4: - val = read_4s (p); - ret = p + 4; - break; - case DW_EH_PE_sdata8: - val = read_8s (p); - ret = p + 8; - break; - - default: - abort (); - } - - if (val != 0) - switch (encoding & 0xf0) - { - case DW_EH_PE_absptr: - break; - case DW_EH_PE_pcrel: - val += (_Unwind_Ptr) p; - break; - case DW_EH_PE_textrel: - val += (_Unwind_Ptr) bases->tbase; - break; - case DW_EH_PE_datarel: - val += (_Unwind_Ptr) bases->dbase; - break; - case DW_EH_PE_funcrel: - val += (_Unwind_Ptr) bases->func; - break; - default: - abort (); - } - - *pptr = (void *) (_Unwind_Ptr) val; - return ret; -} +read_8s (const void *p) { const union unaligned *up = p; return up->s8; } /* Get the value of register REG as saved in CONTEXT. */ @@ -332,13 +211,13 @@ _Unwind_GetTextRelBase (struct _Unwind_Context *context) unit F belongs to. Return a pointer to the byte after the augmentation, or NULL if we encountered an undecipherable augmentation. */ -static unsigned char * +static const unsigned char * extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context, _Unwind_FrameState *fs) { - unsigned char *aug = cie->augmentation; - unsigned char *p = aug + strlen (aug) + 1; - unsigned char *ret = NULL; + const unsigned char *aug = cie->augmentation; + const unsigned char *p = aug + strlen (aug) + 1; + const unsigned char *ret = NULL; _Unwind_Word code_align; _Unwind_Sword data_align; @@ -349,6 +228,7 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context, fs->code_align = code_align; fs->data_align = data_align; fs->retaddr_column = *p++; + fs->lsda_encoding = DW_EH_PE_omit; /* If the augmentation starts with 'z', then a uleb128 immediately follows containing the length of the augmentation field following @@ -373,20 +253,25 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context, aug += 2; } - /* "R" indicates a byte indicating how addresses are encoded. */ - else if (aug[0] == 'R') + /* "L" indicates a byte showing how the LSDA pointer is encoded. */ + else if (aug[0] == 'L') { - fs->addr_encoding = *p++; + fs->lsda_encoding = *p++; aug += 1; } - /* "P" indicates a personality routine in the CIE augmentation - and an lsda pointer in the FDE augmentation. */ + /* "R" indicates a byte indicating how FDE addresses are encoded. */ + else if (aug[0] == 'R') + { + fs->fde_encoding = *p++; + aug += 1; + } + + /* "P" indicates a personality routine in the CIE augmentation. */ else if (aug[0] == 'P') { - p = read_encoded_pointer (p, fs->addr_encoding, &context->bases, - (void **) &fs->personality); - fs->saw_lsda = 1; + p = read_encoded_value (context, *p, p + 1, + (_Unwind_Ptr *) &fs->personality); aug += 1; } @@ -404,7 +289,7 @@ extract_cie_info (struct dwarf_cie *cie, struct _Unwind_Context *context, onto the stack to start. */ static _Unwind_Word -execute_stack_op (unsigned char *op_ptr, unsigned char *op_end, +execute_stack_op (const unsigned char *op_ptr, const unsigned char *op_end, struct _Unwind_Context *context, _Unwind_Word initial) { _Unwind_Word stack[64]; /* ??? Assume this is enough. */ @@ -800,8 +685,10 @@ execute_stack_op (unsigned char *op_ptr, unsigned char *op_end, CIE info, and the PC range to evaluate. */ static void -execute_cfa_program (unsigned char *insn_ptr, unsigned char *insn_end, - struct _Unwind_Context *context, _Unwind_FrameState *fs) +execute_cfa_program (const unsigned char *insn_ptr, + const unsigned char *insn_end, + struct _Unwind_Context *context, + _Unwind_FrameState *fs) { struct frame_state_reg_info *unused_rs = NULL; @@ -832,8 +719,8 @@ execute_cfa_program (unsigned char *insn_ptr, unsigned char *insn_end, else switch (insn) { case DW_CFA_set_loc: - insn_ptr = read_encoded_pointer (insn_ptr, fs->addr_encoding, - &context->bases, &fs->pc); + insn_ptr = read_encoded_value (context, fs->fde_encoding, + insn_ptr, (_Unwind_Ptr *) &fs->pc); break; case DW_CFA_advance_loc1: @@ -989,7 +876,7 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) { struct dwarf_fde *fde; struct dwarf_cie *cie; - unsigned char *aug, *insn, *end; + const unsigned char *aug, *insn, *end; memset (fs, 0, sizeof (*fs)); context->args_size = 0; @@ -1011,8 +898,7 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) #endif } - context->bases.func = fde->pc_begin; - fs->pc = fde->pc_begin; + fs->pc = context->bases.func; cie = get_cie (fde); insn = extract_cie_info (cie, context, fs); @@ -1026,6 +912,7 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) /* Locate augmentation for the fde. */ aug = (unsigned char *)fde + sizeof (*fde); + aug += 2 * size_of_encoded_value (fs->fde_encoding); insn = NULL; if (fs->saw_z) { @@ -1033,9 +920,9 @@ uw_frame_state_for (struct _Unwind_Context *context, _Unwind_FrameState *fs) aug = read_uleb128 (aug, &i); insn = aug + i; } - if (fs->saw_lsda) - aug = read_encoded_pointer (aug, fs->addr_encoding, - &context->bases, &context->lsda); + if (fs->lsda_encoding != DW_EH_PE_omit) + aug = read_encoded_value (context, fs->lsda_encoding, aug, + (_Unwind_Ptr *) &context->lsda); /* Then the insns in the FDE up to our target PC. */ if (insn == NULL) @@ -1076,7 +963,7 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs) CFA calculation is so complicated as to require a stack program that this will not be a problem. */ { - unsigned char *exp = fs->cfa_exp; + const unsigned char *exp = fs->cfa_exp; _Unwind_Word len; exp = read_uleb128 (exp, &len); @@ -1104,7 +991,7 @@ uw_update_context_1 (struct _Unwind_Context *context, _Unwind_FrameState *fs) break; case REG_SAVED_EXP: { - unsigned char *exp = fs->regs.reg[i].loc.exp; + const unsigned char *exp = fs->regs.reg[i].loc.exp; _Unwind_Word len; _Unwind_Ptr val; diff --git a/gcc/unwind-pe.h b/gcc/unwind-pe.h index f940342b03d..264aa1821d8 100644 --- a/gcc/unwind-pe.h +++ b/gcc/unwind-pe.h @@ -74,7 +74,7 @@ size_of_encoded_value (unsigned char encoding) not available. */ static _Unwind_Ptr -base_of_encoded_value (unsigned char encoding, _Unwind_Context *context) +base_of_encoded_value (unsigned char encoding, struct _Unwind_Context *context) { if (encoding == DW_EH_PE_omit) return 0; @@ -204,7 +204,7 @@ read_encoded_value_with_base (unsigned char encoding, _Unwind_Ptr base, rather than providing it directly. */ static inline const unsigned char * -read_encoded_value (_Unwind_Context *context, unsigned char encoding, +read_encoded_value (struct _Unwind_Context *context, unsigned char encoding, const unsigned char *p, _Unwind_Ptr *val) { return read_encoded_value_with_base (encoding,