8sa1-gcc/gcc/frame.c
Andrew MacLeod ce152ef836 except.c (func_eh_entry): Add emitted field.
2000-05-25  Andrew MacLeod  <amacleod@cygnus.com>
            Andrew Haley  <aph@cygnus.com>

	* except.c  (func_eh_entry): Add emitted field.
	(new_eh_region_entry): Set emitted field to 0;
	(output_exception_table_entry): Only emit previously un-emitted data,
	and send it to the eh_data section.
	(output_exception_table): Break out common parts. Output
	exception table for entire compilation unit to eh_data section.
	(output_exception_table_data): Common parts of output_exception_table.
	Send output to eh_data section.
	(output_function_exception_table): Output exception table data for
	a single function to eh_data section.
	(free_exception_table): New external to free the table.
	* except.h (free_exception_table): Add prototype.
	(output_function_exception_table): Add prototype.
	* final.c (final_end_function): Output function exception table
	for IA64_UNWIND_INFO.
	(final_scan_insn): Emit any unwind directives for an insn.

	* frame-dwarf2.c: New file containing all DWARF 2 specific code
	from frame.c.
	* frame.c: Remove all DWARF 2 specific code.
	* config/ia64/frame-ia64.c: New file.
	(gthread_stuff): Make all gthread available with
	IA64_UNWIND_INFO.
	(dwarf_fde): Define an IA64 struct for dwarf_fde.
	(__register_frame_info, __register_frame): Move to common area of file.
	(__register_frame_info_table, __register_frame_table): Move to common i
	area.
	(__deregister_frame_info, __deregister_frame): Move to common area.
	(__frame_init, find_fde): New versions for IA64_UNWIND_INFO.
	(read_uleb128): New version for ia64.
	(get_unwind_record): Read the next IA-64 unwind record.
	(read_R_record): Read a region header record.
	(process_a_b_reg_code): X record helper.
	(read_X_record): Read an X format record.
	(read_B_record): Read a B format record.
	(P3_record_types): List of record types matching the P3 format.
	(P7_record_types): List of record types matching the P7 format.
	(P8_record_types): List of record types matching the P8 format.
	(read_P_record): Read a P format record.
	(init_ia64_reg_loc): Set default fields for a register.
	(init_ia64_unwind_frame): Set defaults for all register records.
	(execute_one_ia64_descriptor): Execute one descriptor record.
	(rse_address_add): Calculate the position of a local reg in memory.
	(normalize_reg_loc): Turn a location descriptor into a memory address.
	(maybe_normalize_reg_loc): Only normalize a descriptor if it falls
	within a specified PC offset range.
	(get_real_reg_value): Given a register location, retrieve its value.
	(set_real_reg_value): Change the value of a register location.
	(copy_reg_value): Copy reg values, if needed.
	(copy_saved_reg_state): Copy all registers that need to be copied.
	(process_state_between): Normalize all frame register records that
	fall within the specified PC range.
	(frame_translate): Take a processed frame description, and turn
	everything into addresses.
	(build_ia64_frame_state ): Find and create frame state record for a PC.
	(get_personality): Get the personality routine for a given frame.
	(get_except_table): Get the exception table for a given frame.
	(record_name): Unwind record names for debugging.
	(print_record): Print and unwind record.
	(print_all_records): Print an entire unwind image.
	(__ia64_backtrace): Print a backtrace.
	(ia64_backtrace_helper): New function.
	(__register_frame_info_aux): New function.
	* config/ia64/crtend.asm (__do_frame_setup_aux): New function.

	* frame.h (enum unw_record_type): New unwind record types.
	(struct unw_p_record, unw_b_record, unw_x_record) : New unwind records.
	(struct unw_r_record, unwind_record): New unwind record structs.
	(struct unwind_info_ptr): Unwind information layout.
	(IA64_UNW_LOC_TYPE_*): Macros for different types for location
	descriptors.
	(struct ia64_reg_loc): Register location description.
	(struct ia64_frame_state): Location of all registers in a frame.
	(struct object): Add pc_base and fde_end for IA64_UNWIND_INFO.
	* libgcc2.c (__ia64_personality_v1): Personality routine.
	(__calc_caller_bsp): Calculate the bsp register for the caller's
	frame.
	(ia64_throw_helper): Figure out who to return to and set up the
	registers.
	(__throw): Throw routine.

	* output.h (assemble_eh_align, assemble_eh_label): New functions
	to generate EH info where we want it.
	(assemble_eh_integer): New function.
	* toplev.c (compile_file): Output module level exception table for
	non-ia64 targets.
	(main): Set exceptions_via_longjump and flag_new_exceptions based
	on IA64_UNWIND_INFO too.

	* varasm.c (assemble_eh_label): Generate a label via
	ASM_OUTPUT_EH_LABEL if it has been specified.
	(assemble_eh_align): Generate an alignment directive via
	ASM_OUTPUT_EH_ALIGN if it has been specified.
	(assemble_eh_label): Generate an integer value via
	ASM_OUTPUT_EH_type if they have been specified.
	* config/ia64/ia64.c (rtx_needs_barrier): Add flushrs.
	(ia64_init_builtins): Add __builtin_ia64_bsp
	and __builtin_ia64_flushrs.
	(ia64_expand_builtin): Add IA64_BUILTIN_BSP and
	IA64_BUILTIN_FLUSHRS.
	* config/ia64/ia64.h (ia64_builtins): Add IA64_BUILTIN_BSP and
	IA64_BUILTIN_FLUSHRS.

	* config/ia64/ia64.md (flushrs): New insn to flush the register
	stack.  Add to unspec list.

	* config/ia64/crtbegin.asm (frame_object): Change size.
	(__do_frame_setup_aux): New function.
	* config/ia64/crtend.asm: call __do_frame_setup_aux.
	* config/ia64/t-ia64 (LIB2ADDEH): Add.
	* Makefile.in (LIB2ADDEH): Add.
	(LIB2ADD): Use LIB2ADDEH.

Co-Authored-By: Andrew Haley <aph@cygnus.com>

From-SVN: r34169
2000-05-25 15:21:51 +00:00

339 lines
9.6 KiB
C

/* Subroutines needed for unwinding stack frames for exception handling. */
/* Compile this one with gcc. */
/* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
Contributed by Jason Merrill <jason@cygnus.com>.
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file. (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combine
executable.)
GNU CC 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
/* 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.) */
/* 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.
I.e. a linearly increasing sequence (coming from functions in the text
section), with additionally a few unordered elements (coming from functions
in gnu_linkonce sections) whose values are higher than the values in the
surrounding linear sequence (but not necessarily higher than the values
at the end of the linear sequence!).
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
{
fde **array;
size_t count;
} fde_vector;
typedef struct fde_accumulator
{
fde_vector linear;
fde_vector erratic;
} fde_accumulator;
static inline int
start_fde_sort (fde_accumulator *accu, size_t count)
{
accu->linear.array = (fde **) malloc (sizeof (fde *) * count);
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;
}
static inline void
fde_insert (fde_accumulator *accu, fde *this_fde)
{
if (accu->linear.array)
accu->linear.array[accu->linear.count++] = this_fde;
}
/* Split LINEAR into a linear sequence with low values and an erratic
sequence with high values, put the linear one (of longest possible
length) into LINEAR and the erratic one into ERRATIC. This is O(N).
Because the longest linear sequence we are trying to locate within the
incoming LINEAR array can be interspersed with (high valued) erratic
entries. We construct a chain indicating the sequenced entries.
To avoid having to allocate this chain, we overlay it onto the space of
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)
{
static fde *marker;
size_t count = linear->count;
fde **chain_end = &marker;
size_t i, j, k;
/* This should optimize out, but it is wise to make sure this assumption
is correct. Should these have different sizes, we cannot cast between
them and the overlaying onto ERRATIC will not work. */
if (sizeof (fde *) != sizeof (fde **))
abort ();
for (i = 0; i < count; i++)
{
fde **probe;
for (probe = chain_end;
probe != &marker && fde_compare (linear->array[i], *probe) < 0;
probe = chain_end)
{
chain_end = (fde **)erratic->array[probe - linear->array];
erratic->array[probe - linear->array] = NULL;
}
erratic->array[i] = (fde *)chain_end;
chain_end = &linear->array[i];
}
/* Each entry in LINEAR which is part of the linear sequence we have
discovered will correspond to a non-NULL entry in the chain we built in
the ERRATIC array. */
for (i = j = k = 0; i < count; i++)
if (erratic->array[i])
linear->array[j++] = linear->array[i];
else
erratic->array[k++] = linear->array[i];
linear->count = j;
erratic->count = k;
}
/* 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)
{
/* For a description of this algorithm, see:
Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
p. 60-61. */
fde ** a = erratic->array;
/* A portion of the array is called a "heap" if for all i>=0:
If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
#define SWAP(x,y) do { fde * tmp = x; x = y; y = tmp; } while (0)
size_t n = erratic->count;
size_t m = n;
size_t i;
while (m > 0)
{
/* Invariant: a[m..n-1] is a heap. */
m--;
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)
{
SWAP (a[i], a[2*i+2]);
i = 2*i+2;
}
else if (fde_compare (a[2*i+1], a[i]) > 0)
{
SWAP (a[i], a[2*i+1]);
i = 2*i+1;
}
else
break;
}
}
while (n > 1)
{
/* Invariant: a[0..n-1] is a heap. */
n--;
SWAP (a[0], a[n]);
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)
{
SWAP (a[i], a[2*i+2]);
i = 2*i+2;
}
else if (fde_compare (a[2*i+1], a[i]) > 0)
{
SWAP (a[i], a[2*i+1]);
i = 2*i+1;
}
else
break;
}
}
#undef SWAP
}
/* Merge V1 and V2, both sorted, and put the result into V1. */
static void
fde_merge (fde_vector *v1, const fde_vector *v2)
{
size_t i1, i2;
fde * fde2;
i2 = v2->count;
if (i2 > 0)
{
i1 = v1->count;
do {
i2--;
fde2 = v2->array[i2];
while (i1 > 0 && fde_compare (v1->array[i1-1], fde2) > 0)
{
v1->array[i1+i2] = v1->array[i1-1];
i1--;
}
v1->array[i1+i2] = fde2;
} while (i2 > 0);
v1->count += v2->count;
}
}
static fde **
end_fde_sort (fde_accumulator *accu, size_t count)
{
if (accu->linear.array && accu->linear.count != count)
abort ();
if (accu->erratic.array)
{
fde_split (&accu->linear, &accu->erratic);
if (accu->linear.count + accu->erratic.count != count)
abort ();
frame_heapsort (&accu->erratic);
fde_merge (&accu->linear, &accu->erratic);
if (accu->erratic.array)
free (accu->erratic.array);
}
else
{
/* We've not managed to malloc an erratic array, so heap sort in the
linear one. */
frame_heapsort (&accu->linear);
}
return accu->linear.array;
}
/* Called from crtbegin.o to register the unwind info for an object. */
void
__register_frame_info (void *begin, struct object *ob)
{
ob->fde_begin = begin;
ob->pc_begin = ob->pc_end = 0;
ob->fde_array = 0;
ob->count = 0;
init_object_mutex_once ();
__gthread_mutex_lock (&object_mutex);
ob->next = objects;
objects = ob;
__gthread_mutex_unlock (&object_mutex);
}
void
__register_frame (void *begin)
{
struct object *ob = (struct object *) malloc (sizeof (struct object));
__register_frame_info (begin, ob);
}
/* Similar, but BEGIN is actually a pointer to a table of unwind entries
for different translation units. Called from the file generated by
collect2. */
void
__register_frame_info_table (void *begin, struct object *ob)
{
ob->fde_begin = begin;
ob->fde_array = begin;
ob->pc_begin = ob->pc_end = 0;
ob->count = 0;
init_object_mutex_once ();
__gthread_mutex_lock (&object_mutex);
ob->next = objects;
objects = ob;
__gthread_mutex_unlock (&object_mutex);
}
void
__register_frame_table (void *begin)
{
struct object *ob = (struct object *) malloc (sizeof (struct object));
__register_frame_info_table (begin, ob);
}
/* Called from crtbegin.o to deregister the unwind info for an object. */
void *
__deregister_frame_info (void *begin)
{
struct object **p;
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;
/* 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);
}
__gthread_mutex_unlock (&object_mutex);
abort ();
}
void
__deregister_frame (void *begin)
{
free (__deregister_frame_info (begin));
}