* *
* I N I T *
* *
- * $Revision$
+ * $Revision: 1.6 $
* *
* C Implementation File *
* *
#endif
}
-/***************************************/
-/* __gnat_initialize (default version) */
-/***************************************/
-
-/* Get the stack unwinding mechanism when available and when compiling
- a-init.c for the run time. Except in the case of a restricted run-time,
- such as RT-Linux modules (__RT__ is defined). */
-
-#elif defined (IN_RTS) && !defined (__RT__)
-
-/* If we have a definition of INCOMING_RETURN_ADDR_RTX, assume that
- the rest of the DWARF 2 frame unwind support is also provided. */
-#if !defined (DWARF2_UNWIND_INFO) && defined (INCOMING_RETURN_ADDR_RTX)
-#define DWARF2_UNWIND_INFO 1
-#endif
-
-#ifdef DWARF2_UNWIND_INFO
-#include "frame.h"
-
-struct machine_state
-{
- frame_state f1, f2, f3;
- frame_state *udata, *udata_start, *sub_udata;
- void *pc, *pc_start, *new_pc;
-};
-
-typedef int word_type __attribute__ ((mode (__word__)));
-
-/* This type is used in get_reg and put_reg to deal with ABIs where a void*
- is smaller than a word, such as the Irix 6 n32 ABI. We cast twice to
- avoid a warning about casting between int and pointer of different
- sizes. */
-
-typedef int ptr_type __attribute__ ((mode (pointer)));
-
-static void get_reg PARAMS ((unsigned int, frame_state *,
- frame_state *));
-static void put_reg PARAMS ((unsigned int, void *,
- frame_state *));
-static void copy_reg PARAMS ((unsigned int, frame_state *,
- frame_state *));
-static inline void put_return_addr PARAMS ((void *, frame_state *));
-static inline void *get_return_addr PARAMS ((frame_state *,
- frame_state *));
-static frame_state *__frame_state_for_r PARAMS ((void *, frame_state *));
-
-#ifdef INCOMING_REGNO
-static int in_reg_window PARAMS ((unsigned int, frame_state *));
-#endif
-
-extern void __gnat_pop_frame PARAMS ((struct machine_state *));
-extern void __gnat_set_machine_state PARAMS ((struct machine_state *));
-extern void __gnat_enter_handler PARAMS ((struct machine_state *,
- void *));
-extern __SIZE_TYPE__ __gnat_machine_state_length PARAMS ((void));
-extern void *__gnat_get_code_loc PARAMS ((struct machine_state *));
-
-/* Get the value of register REG as saved in UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
-
-static void *
-get_reg (reg, udata, sub_udata)
- unsigned int reg;
- frame_state *udata, *sub_udata;
-{
- if (udata->saved[reg] == REG_SAVED_OFFSET)
- return
- (void *) (ptr_type) *(word_type *) (udata->cfa
- + udata->reg_or_offset[reg]);
- else if (udata->saved[reg] == REG_SAVED_REG && sub_udata)
- return get_reg (udata->reg_or_offset[reg], sub_udata, 0);
- else
- abort ();
-}
-
-/* Overwrite the saved value for register REG in frame UDATA with VAL. */
-
-static void
-put_reg (reg, val, udata)
- unsigned int reg;
- void *val;
- frame_state *udate;
-{
- if (udata->saved[reg] == REG_SAVED_OFFSET)
- *(word_type *) (udata->cfa + udata->reg_or_offset[reg])
- = (word_type) (ptr_type) val;
- else
- abort ();
-}
-
-/* Copy the saved value for register REG from frame UDATA to frame
- TARGET_UDATA. Unlike the previous two functions, this can handle
- registers that are not one word large. */
-
-static void
-copy_reg (reg, udata, target_udata)
- unsigned int reg;
- frame_state *udate, *target_udata;
-{
- if (udata->saved[reg] == REG_SAVED_OFFSET
- && target_udata->saved[reg] == REG_SAVED_OFFSET)
- memcpy (target_udata->cfa + target_udata->reg_or_offset[reg],
- udata->cfa + udata->reg_or_offset[reg],
- __builtin_dwarf_reg_size (reg));
- else
- abort ();
-}
-
-/* Overwrite the return address for frame UDATA with VAL. */
-
-static inline void
-put_return_addr (val, udata)
- void *val;
- frame_state *udata;
-{
- val = __builtin_frob_return_addr (val);
- put_reg (udata->retaddr_column, val, udata);
-}
-
-#ifdef INCOMING_REGNO
-
-/* Is the saved value for register REG in frame UDATA stored in a register
- window in the previous frame? */
-
-static int
-in_reg_window (reg, udata)
- unsigned int reg;
- frame_state *udata;
-{
- if (udata->saved[reg] != REG_SAVED_OFFSET)
- return 0;
-
-#ifdef STACK_GROWS_DOWNWARD
- return udata->reg_or_offset[reg] > 0;
-#else
- return udata->reg_or_offset[reg] < 0;
-#endif
-}
-#endif /* INCOMING_REGNO */
-
-/* Retrieve the return address for frame UDATA, where SUB_UDATA is a
- frame called by UDATA or 0. */
-
-static inline void *
-get_return_addr (udata, sub_udata)
- frame_state *udate, *sub_udata;
-{
- return __builtin_extract_return_addr (get_reg (udata->retaddr_column,
- udata, sub_udata));
-}
-
-/* Thread-safe version of __frame_state_for */
-
-static frame_state *
-__frame_state_for_r (void *pc_target, frame_state *state_in)
- void *pc_target;
- frame_state *state_in;
-{
- frame_state *f;
-
- (*Lock_Task) ();
- f = __frame_state_for (pc_target, state_in);
- (*Unlock_Task) ();
- return f;
-}
-
-/* Given the current frame UDATA and its return address PC, return the
- information about the calling frame in CALLER_UDATA. */
-
-void
-__gnat_pop_frame (m)
- struct machine_state *m;
-{
- frame_state *p;
-
- int i;
-
- m->pc = m->new_pc;
- p = m->udata;
- if (! __frame_state_for_r (m->pc, m->sub_udata))
- {
- m->new_pc = 0;
- return;
- }
-
- /* Now go back to our caller's stack frame. If our caller's CFA register
- was saved in our stack frame, restore it; otherwise, assume the CFA
- register is SP and restore it to our CFA value. */
- if (m->udata->saved[m->sub_udata->cfa_reg])
- m->sub_udata->cfa = get_reg (m->sub_udata->cfa_reg, m->udata, 0);
- else
- m->sub_udata->cfa = m->udata->cfa;
- m->sub_udata->cfa += m->sub_udata->cfa_offset;
-
- m->udata = m->sub_udata;
- m->sub_udata = p;
- m->new_pc = get_return_addr (m->udata, m->sub_udata) - 1;
-
- return;
-
-/* ??? disable this code for now since it doesn't work properly */
-#if 0
- if (m->pc == m->pc_start)
- return;
-
- /* Copy the frame's saved register values into our register save slots. */
-
- for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
- if (i != m->udata->retaddr_column && m->udata->saved[i])
- {
-#ifdef INCOMING_REGNO
- /* If you modify the saved value of the return address
- register on the SPARC, you modify the return address for
- your caller's frame. Don't do that here, as it will
- confuse get_return_addr. */
- if (in_reg_window (i, m->udata)
- && m->udata->saved[m->udata->retaddr_column] == REG_SAVED_REG
- && m->udata->reg_or_offset[m->udata->retaddr_column] == i)
- continue;
-#endif
- copy_reg (i, m->udata, m->udata_start);
- }
-#endif
-}
-
-void
-__gnat_set_machine_state (machine_state)
- struct machine_state *machine_state;
-{
- frame_state sub_udata;
-
- /* Start at our stack frame. */
-label:
- machine_state->udata = &machine_state->f1;
- machine_state->sub_udata = &machine_state->f2;
- machine_state->udata_start = &machine_state->f3;
-
- if (! __frame_state_for_r (&&label, machine_state->udata))
- return;
-
- /* We need to get the value from the CFA register. At this point in
- compiling libgnat.a we don't know whether or not we will use the frame
- pointer register for the CFA, so we check our unwind info. */
- if (machine_state->udata->cfa_reg == __builtin_dwarf_fp_regnum ())
- machine_state->udata->cfa = __builtin_fp ();
- else
- machine_state->udata->cfa = __builtin_sp ();
- machine_state->udata->cfa += machine_state->udata->cfa_offset;
-
- memcpy (machine_state->udata_start, machine_state->udata,
- sizeof (frame_state));
- machine_state->new_pc =
- machine_state->pc_start =
- machine_state->pc = &&label;
-
- /* Do any necessary initialization to access arbitrary stack frames.
- On the SPARC, this means flushing the register windows. */
- __builtin_unwind_init ();
-
- /* go up one frame */
- __gnat_pop_frame (machine_state);
-}
-
-void
-__gnat_enter_handler (m, handler)
- struct machine_state *m;
- void *handler;
-{
- void *retaddr;
-
-#ifdef INCOMING_REGNO
- /* we need to update the saved return address register from
- the last frame we unwind, or the handler frame will have the wrong
- return address. */
- if (m->udata->saved[m->udata->retaddr_column] == REG_SAVED_REG)
- {
- int i = m->udata->reg_or_offset[m->udata->retaddr_column];
- if (in_reg_window (i, m->udata))
- copy_reg (i, m->udata, m->udata_start);
- }
-#endif
-
- /* Emit the stub to adjust sp and jump to the handler. */
- retaddr = __builtin_eh_stub ();
-
- /* And then set our return address to point to the stub. */
- if (m->udata_start->saved[m->udata_start->retaddr_column] ==
- REG_SAVED_OFFSET)
- put_return_addr (retaddr, m->udata_start);
- else
- __builtin_set_return_addr_reg (retaddr);
-
- /* Set up the registers we use to communicate with the stub.
- We check STACK_GROWS_DOWNWARD so the stub can use adjust_stack. */
- __builtin_set_eh_regs
- (handler,
-#ifdef STACK_GROWS_DOWNWARD
- m->udata->cfa - m->udata_start->cfa
-#else
- m->udata_start->cfa - m->udata->cfa
-#endif
- + m->udata->args_size);
-
- /* Epilogue: restore the handler frame's register values and return
- to the stub. */
-}
-
-__SIZE_TYPE__
-__gnat_machine_state_length ()
-{
- return sizeof (struct machine_state);
-}
-
-void *
-__gnat_get_code_loc (m)
- struct machine_state *m;
-{
- return m->pc;
-}
-#endif /* DWARF2_UNWIND_INFO */
-
#else
/* For all other versions of GNAT, the initialize routine and handler
projects / gcc.git / commitdiff