ia64 prologue/epilogue rewrite 3/N
Richard Henderson
rth@cygnus.com
Tue Aug 8 02:15:00 GMT 2000
The biggest thing here is that we didn't handle functions without
a frame pointer at all. No, really. So when I went and made that
the default, every single EH test failed.
So is there any reason why we couldn't iterate over optimization
levels in the C++ testsuite?
r~
* frame.h (ia64_frame_state): Add my_psp.
* libgcc2.c (ia64_throw_helper): Add throw_sp argument.
(__throw): Pass it in. Don't clobber r7.
* config/ia64/frame-ia64.c (init_ia64_reg_loc): Mark inline.
(execute_one_ia64_descriptor) [mem_stack_v]: Sets psp.when
and nothing to do with sp.
(normalize_reg_loc): Use frame->my_psp.
(frame_translate): Handle frame-pointer-less functions. Set
spill_base correctly, in absence of being told.
(__build_ia64_frame_state): New sp argument. Fill in frame->my_sp.
(__ia64_backtrace_helper): New sp argument. Use
builtin_return_address instead of label addresses.
(print_record) [mem_stack_v]: No size member.
Index: frame.h
===================================================================
RCS file: /cvs/gcc/egcs/gcc/frame.h,v
retrieving revision 1.15
diff -c -p -d -r1.15 frame.h
*** frame.h 2000/07/04 07:55:39 1.15
--- frame.h 2000/08/08 09:01:31
*************** typedef struct ia64_frame_state
*** 248,253 ****
--- 248,254 ----
ia64_reg_loc sp;
ia64_reg_loc psp;
ia64_reg_loc spill_base;
+ void *my_psp;
void *my_sp;
void *my_bsp;
} ia64_frame_state;
*************** typedef struct unwind_info_ptr
*** 267,273 ****
#define IA64_UNW_HDR_VERSION(x) (((x) >> 48) & 0xffffUL)
extern unwind_info_ptr *__build_ia64_frame_state (unsigned char *,
! ia64_frame_state *, void *,
void **);
extern void *__get_real_reg_value (ia64_reg_loc *);
extern void *__get_personality (unwind_info_ptr *);
--- 268,275 ----
#define IA64_UNW_HDR_VERSION(x) (((x) >> 48) & 0xffffUL)
extern unwind_info_ptr *__build_ia64_frame_state (unsigned char *,
! ia64_frame_state *,
! void *, void *,
void **);
extern void *__get_real_reg_value (ia64_reg_loc *);
extern void *__get_personality (unwind_info_ptr *);
Index: libgcc2.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/libgcc2.c,v
retrieving revision 1.98
diff -c -p -d -r1.98 libgcc2.c
*** libgcc2.c 2000/07/10 20:25:56 1.98
--- libgcc2.c 2000/08/08 09:01:31
*************** __ia64_personality_v1 (void *pc, old_exc
*** 4046,4055 ****
}
static void
! ia64_throw_helper (throw_frame, caller, throw_bsp)
! ia64_frame_state *throw_frame;
! ia64_frame_state *caller;
! void *throw_bsp;
{
void *throw_pc = __builtin_return_address (0);
unwind_info_ptr *info;
--- 4046,4053 ----
}
static void
! ia64_throw_helper (ia64_frame_state *throw_frame, ia64_frame_state *caller,
! void *throw_bsp, void *throw_sp)
{
void *throw_pc = __builtin_return_address (0);
unwind_info_ptr *info;
*************** ia64_throw_helper (throw_frame, caller,
*** 4061,4067 ****
__builtin_ia64_flushrs (); /* Make the local register stacks available. */
/* Start at our stack frame, get our state. */
! __build_ia64_frame_state (throw_pc, throw_frame, throw_bsp, &pc_base);
/* Now we have to find the proper frame for pc, and see if there
is a handler for it. if not, we keep going back frames until
--- 4059,4066 ----
__builtin_ia64_flushrs (); /* Make the local register stacks available. */
/* Start at our stack frame, get our state. */
! __build_ia64_frame_state (throw_pc, throw_frame, throw_bsp, throw_sp,
! &pc_base);
/* Now we have to find the proper frame for pc, and see if there
is a handler for it. if not, we keep going back frames until
*************** ia64_throw_helper (throw_frame, caller,
*** 4078,4085 ****
/* We only care about the RP right now, so we dont need to keep
any other information about a call frame right now. */
pc = __get_real_reg_value (&caller->rp) - 1;
! bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs), caller->my_bsp);
! info = __build_ia64_frame_state (pc, caller, bsp, &pc_base);
/* If we couldn't find the next frame, we lose. */
if (! info)
--- 4077,4086 ----
/* We only care about the RP right now, so we dont need to keep
any other information about a call frame right now. */
pc = __get_real_reg_value (&caller->rp) - 1;
! bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs),
! caller->my_bsp);
! info = __build_ia64_frame_state (pc, caller, bsp, caller->my_psp,
! &pc_base);
/* If we couldn't find the next frame, we lose. */
if (! info)
*************** ia64_throw_helper (throw_frame, caller,
*** 4099,4105 ****
}
if (!handler)
! __terminate ();
/* Handler is a segment relative address, so we must adjust it here. */
handler += (long) pc_base;
--- 4100,4106 ----
}
if (!handler)
! __terminate ();
/* Handler is a segment relative address, so we must adjust it here. */
handler += (long) pc_base;
*************** ia64_throw_helper (throw_frame, caller,
*** 4116,4123 ****
for ( ; frame_count > 0; frame_count--)
{
pc = __get_real_reg_value (&caller->rp) - 1;
! bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs), caller->my_bsp);
! __build_ia64_frame_state (pc, caller, bsp, &pc_base);
/* Any regs that were saved can be put in the throw frame now. */
/* We don't want to copy any saved register from the
target destination, but we do want to load up it's frame. */
--- 4117,4125 ----
for ( ; frame_count > 0; frame_count--)
{
pc = __get_real_reg_value (&caller->rp) - 1;
! bsp = __calc_caller_bsp ((long)__get_real_reg_value (&caller->pfs),
! caller->my_bsp);
! __build_ia64_frame_state (pc, caller, bsp, caller->my_psp, &pc_base);
/* Any regs that were saved can be put in the throw frame now. */
/* We don't want to copy any saved register from the
target destination, but we do want to load up it's frame. */
*************** ia64_throw_helper (throw_frame, caller,
*** 4130,4141 ****
/* TODO, do we need to do anything to make the values we wrote 'stick'? */
/* DO we need to go through the whole loadrs seqeunce? */
-
}
void
__throw ()
{
struct eh_context *eh = (*get_eh_context) ();
ia64_frame_state my_frame;
ia64_frame_state originator; /* For the context handler is in. */
--- 4132,4144 ----
/* TODO, do we need to do anything to make the values we wrote 'stick'? */
/* DO we need to go through the whole loadrs seqeunce? */
}
+
void
__throw ()
{
+ register void *stack_pointer __asm__("r12");
struct eh_context *eh = (*get_eh_context) ();
ia64_frame_state my_frame;
ia64_frame_state originator; /* For the context handler is in. */
*************** __throw ()
*** 4149,4154 ****
--- 4152,4158 ----
__terminate ();
__builtin_unwind_init ();
+
/* We have to call another routine to actually process the frame
information, which will force all of __throw's local registers into
backing store. */
*************** __throw ()
*** 4156,4162 ****
/* Get the value of ar.bsp while we're here. */
bsp = __builtin_ia64_bsp ();
! ia64_throw_helper (&my_frame, &originator, bsp);
/* Now we have to fudge the bsp by the amount in our (__throw)
frame marker, since the return is going to adjust it by that much. */
--- 4160,4166 ----
/* Get the value of ar.bsp while we're here. */
bsp = __builtin_ia64_bsp ();
! ia64_throw_helper (&my_frame, &originator, bsp, stack_pointer);
/* Now we have to fudge the bsp by the amount in our (__throw)
frame marker, since the return is going to adjust it by that much. */
*************** __throw ()
*** 4165,4175 ****
my_frame.my_bsp);
offset = (char *)my_frame.my_bsp - (char *)tmp_bsp;
tmp_bsp = (char *)originator.my_bsp + offset;
-
- /* A throw handler is trated like a non-local goto, which is architeched
- to set the FP (or PSP) in r7 before branching. gr[0-3] map to
- r4-r7, so we want gr[3]. */
- __set_real_reg_value (&my_frame.gr[3], __get_real_reg_value (&originator.psp));
__builtin_eh_return (tmp_bsp, offset, originator.my_sp);
--- 4169,4174 ----
Index: config/ia64/frame-ia64.c
===================================================================
RCS file: /cvs/gcc/egcs/gcc/config/ia64/frame-ia64.c,v
retrieving revision 1.2
diff -c -p -d -r1.2 frame-ia64.c
*** config/ia64/frame-ia64.c 2000/06/07 02:27:51 1.2
--- config/ia64/frame-ia64.c 2000/08/08 09:01:31
*************** read_P_record (data, val, ptr, header)
*** 678,684 ****
/* Frame processing routines. */
/* Initialize a single register structure. */
! static void
init_ia64_reg_loc (reg, size)
ia64_reg_loc *reg;
short size;
--- 678,684 ----
/* Frame processing routines. */
/* Initialize a single register structure. */
! static inline void
init_ia64_reg_loc (reg, size)
ia64_reg_loc *reg;
short size;
*************** init_ia64_reg_loc (reg, size)
*** 692,698 ****
/* Iniitialize an entire frame to the default of nothing. */
static void
init_ia64_unwind_frame (frame)
! ia64_frame_state *frame ;
{
int x;
--- 692,698 ----
/* Iniitialize an entire frame to the default of nothing. */
static void
init_ia64_unwind_frame (frame)
! ia64_frame_state *frame;
{
int x;
*************** execute_one_ia64_descriptor (addr, frame
*** 741,747 ****
*len = -1;
addr = get_unwind_record (®ion_header, &r, addr);
! /* process it in 2 phases, the first phase will either do the work,
or set up a pointer to the records we care about
(ie a special purpose ar perhaps, and the second will actually
fill in the record. */
--- 741,747 ----
*len = -1;
addr = get_unwind_record (®ion_header, &r, addr);
! /* Process it in 2 phases, the first phase will either do the work,
or set up a pointer to the records we care about
(ie a special purpose ar perhaps, and the second will actually
fill in the record. */
*************** execute_one_ia64_descriptor (addr, frame
*** 787,796 ****
break;
}
case mem_stack_f:
- case mem_stack_v:
- frame->sp.when = r.record.p.t;
frame->sp.l.offset = r.record.p.size;
frame->sp.loc_type = IA64_UNW_LOC_TYPE_OFFSET;
break;
case psp_gr:
case psp_sprel:
--- 787,798 ----
break;
}
case mem_stack_f:
frame->sp.l.offset = r.record.p.size;
frame->sp.loc_type = IA64_UNW_LOC_TYPE_OFFSET;
+ frame->sp.when = r.record.p.t;
+ break;
+ case mem_stack_v:
+ frame->psp.when = r.record.p.t;
break;
case psp_gr:
case psp_sprel:
*************** normalize_reg_loc (frame, reg)
*** 1091,1097 ****
case IA64_UNW_LOC_TYPE_BR:
break;
case IA64_UNW_LOC_TYPE_SPOFF:
! /* offset from the stack pointer, calculate the memory address
now. */
tmp = (unsigned char *)frame->my_sp + reg->l.offset * 4;
reg->l.mem = tmp;
--- 1093,1099 ----
case IA64_UNW_LOC_TYPE_BR:
break;
case IA64_UNW_LOC_TYPE_SPOFF:
! /* Offset from the stack pointer, calculate the memory address
now. */
tmp = (unsigned char *)frame->my_sp + reg->l.offset * 4;
reg->l.mem = tmp;
*************** normalize_reg_loc (frame, reg)
*** 1100,1106 ****
case IA64_UNW_LOC_TYPE_PSPOFF:
/* Actualy go get the value of the PSP add the offset, and thats
the mem location we can find this value at. */
! tmp = (*(unsigned char **)(frame->psp.l.mem)) + 16 - reg->l.offset * 4;
reg->l.mem = tmp;
reg->loc_type = IA64_UNW_LOC_TYPE_MEM;
break;
--- 1102,1108 ----
case IA64_UNW_LOC_TYPE_PSPOFF:
/* Actualy go get the value of the PSP add the offset, and thats
the mem location we can find this value at. */
! tmp = (unsigned char *)frame->my_psp + 16 - reg->l.offset * 4;
reg->l.mem = tmp;
reg->loc_type = IA64_UNW_LOC_TYPE_MEM;
break;
*************** normalize_reg_loc (frame, reg)
*** 1114,1120 ****
}
}
! /* this function looks at a reg_loc and determines if its going
to be an executed record or not between time start and end.
It is executed if it is exectued at START time. It is NOT
executed if it happens at END time. */
--- 1116,1123 ----
}
}
!
! /* This function looks at a reg_loc and determines if its going
to be an executed record or not between time start and end.
It is executed if it is exectued at START time. It is NOT
executed if it happens at END time. */
*************** copy_reg_value (src, dest)
*** 1173,1179 ****
else
{
void **d;
! if (src->reg_size> 16)
abort ();
if (dest->loc_type != IA64_UNW_LOC_TYPE_MEM)
abort ();
--- 1176,1182 ----
else
{
void **d;
! if (src->reg_size > 16)
abort ();
if (dest->loc_type != IA64_UNW_LOC_TYPE_MEM)
abort ();
*************** process_state_between (frame, start, end
*** 1218,1224 ****
/* PSP, RP, SP, and PFS are handled seperately from here. */
/* GR's, FR's and BR's are saved at an arbitrary point, so we
! should handle them at teh very beginning. */
if (start == 0)
{
for (x = 0; x < 4 ; x++)
--- 1221,1229 ----
/* PSP, RP, SP, and PFS are handled seperately from here. */
/* GR's, FR's and BR's are saved at an arbitrary point, so we
! should handle them at the very beginning. */
! /* ??? Err, no they aren't. There's the spill_mask record that
! tells us when each is processed. */
if (start == 0)
{
for (x = 0; x < 4 ; x++)
*************** frame_translate (frame, unwind_time)
*** 1252,1276 ****
ia64_frame_state *frame;
long unwind_time;
{
! /* First, establish values of PFS and PSP and RP, if needed. */
!
! normalize_reg_loc (frame, &frame->pfs);
! normalize_reg_loc (frame, &frame->psp);
! normalize_reg_loc (frame, &frame->rp);
!
if (frame->rp.loc_type == IA64_UNW_LOC_TYPE_NONE)
return;
! /* The stack pointer at the function start is the PSP value
! saved away. */
! frame->my_sp = __get_real_reg_value (&frame->psp);
! if (frame->psp.loc_type != IA64_UNW_LOC_TYPE_MEM)
! abort ();
! /* spill base is set up off the PSP register, which should now
! have its value. */
! normalize_reg_loc (frame, &frame->spill_base);
/* If the SP is adjusted, process records up to where it
is adjusted, then adjust it, then process the rest. */
--- 1257,1308 ----
ia64_frame_state *frame;
long unwind_time;
{
! /* ??? Is this supposed to mark the end of the stack? */
if (frame->rp.loc_type == IA64_UNW_LOC_TYPE_NONE)
return;
! /* At function entry, SP == PSP. */
! frame->my_psp = frame->my_sp;
! if (frame->psp.loc_type != IA64_UNW_LOC_TYPE_NONE)
! {
! /* We've saved a frame pointer somewhere. This will be the
! canonical PSP for the function. */
! normalize_reg_loc (frame, &frame->psp);
! if (frame->psp.when < unwind_time)
! frame->my_psp = __get_real_reg_value (&frame->psp);
! }
! else if (frame->sp.loc_type == IA64_UNW_LOC_TYPE_OFFSET)
! {
! /* We've a fixed sized stack frame. The PSP is at a known offset. */
!
! if (frame->sp.when < unwind_time)
! frame->my_psp = frame->my_sp + frame->sp.l.offset;
! }
! /* Otherwise the stack frame size was zero and no adjustment needed. */
! /* Find PFS, RP and the spill base. All of which might have
! addresses based off the PSP computed above. */
! normalize_reg_loc (frame, &frame->pfs);
! normalize_reg_loc (frame, &frame->rp);
! if (frame->spill_base.loc_type != IA64_UNW_LOC_TYPE_NONE)
! normalize_reg_loc (frame, &frame->spill_base);
! else
! {
! /* Otherwise we're supposed to infer it from the size of the
! saved GR/BR/FR registers, putting the top at psp+16. */
! long size = 0, i;
! for (i = 0; i < 4; ++i)
! if (frame->gr[i].when >= 0)
! size += 8;
! for (i = 0; i < 5; ++i)
! if (frame->br[i].when >= 0)
! size += 8;
! for (i = 0; i < 20; ++i)
! if (frame->fr[i].when >= 0)
! size += 16;
! frame->spill_base.l.mem = frame->my_psp + 16 - size;
! }
/* If the SP is adjusted, process records up to where it
is adjusted, then adjust it, then process the rest. */
*************** frame_translate (frame, unwind_time)
*** 1279,1302 ****
process_state_between (frame, 0, frame->sp.when);
if (frame->sp.loc_type != IA64_UNW_LOC_TYPE_OFFSET)
abort ();
! frame->my_sp =
! (unsigned char *)frame->my_sp - frame->sp.l.offset;
process_state_between (frame, frame->sp.when, unwind_time);
}
else
process_state_between (frame, 0, unwind_time);
}
! /* this function will set a frame_state with all the required fields
from a functions unwind descriptors.
pc is the location we need info up until (ie, the unwind point)
frame is the frame_state structure to be set up.
Returns a pointer to the unwind info pointer for the frame. */
unwind_info_ptr *
! __build_ia64_frame_state (pc, frame, bsp, pc_base_ptr)
unsigned char *pc;
ia64_frame_state *frame;
! void *bsp;
void **pc_base_ptr;
{
long len;
--- 1311,1333 ----
process_state_between (frame, 0, frame->sp.when);
if (frame->sp.loc_type != IA64_UNW_LOC_TYPE_OFFSET)
abort ();
! frame->my_sp = frame->my_psp - frame->sp.l.offset;
process_state_between (frame, frame->sp.when, unwind_time);
}
else
process_state_between (frame, 0, unwind_time);
}
! /* This function will set a frame_state with all the required fields
from a functions unwind descriptors.
pc is the location we need info up until (ie, the unwind point)
frame is the frame_state structure to be set up.
Returns a pointer to the unwind info pointer for the frame. */
unwind_info_ptr *
! __build_ia64_frame_state (pc, frame, bsp, sp, pc_base_ptr)
unsigned char *pc;
ia64_frame_state *frame;
! void *bsp, *sp;
void **pc_base_ptr;
{
long len;
*************** __build_ia64_frame_state (pc, frame, bsp
*** 1321,1328 ****
init_ia64_unwind_frame (frame);
frame->my_bsp = bsp;
! /* stop when we get to the end of the descriptor list, or if we
encounter a region whose initial offset is already past the
PC we are unwinding too. */
--- 1352,1360 ----
init_ia64_unwind_frame (frame);
frame->my_bsp = bsp;
+ frame->my_sp = sp;
! /* Stop when we get to the end of the descriptor list, or if we
encounter a region whose initial offset is already past the
PC we are unwinding too. */
*************** __build_ia64_frame_state (pc, frame, bsp
*** 1336,1341 ****
--- 1368,1374 ----
last_region_size = len;
}
}
+
/* Now we go get the actual values. */
frame_translate (frame, pc_offset);
if (pc_base_ptr)
*************** __calc_caller_bsp (pfs, bsp)
*** 1385,1394 ****
}
static int
! ia64_backtrace_helper (void **array, void *throw_pc,
! ia64_frame_state *throw_frame,
! ia64_frame_state *frame, void *bsp, int size)
{
void *pc = NULL;
int frame_count = 0;
unwind_info_ptr *info;
--- 1418,1427 ----
}
static int
! ia64_backtrace_helper (void **array, ia64_frame_state *throw_frame,
! ia64_frame_state *frame, void *bsp, void *sp, int size)
{
+ void *throw_pc = __builtin_return_address (0);
void *pc = NULL;
int frame_count = 0;
unwind_info_ptr *info;
*************** ia64_backtrace_helper (void **array, voi
*** 1396,1402 ****
__builtin_ia64_flushrs (); /* Make the local register stacks available. */
/* Start at our stack frame, get our state. */
! info = __build_ia64_frame_state (throw_pc, throw_frame, bsp, NULL);
*frame = *throw_frame;
--- 1429,1435 ----
__builtin_ia64_flushrs (); /* Make the local register stacks available. */
/* Start at our stack frame, get our state. */
! info = __build_ia64_frame_state (throw_pc, throw_frame, bsp, sp, NULL);
*frame = *throw_frame;
*************** ia64_backtrace_helper (void **array, voi
*** 1406,1412 ****
--pc;
bsp = __calc_caller_bsp
((long)__get_real_reg_value (&frame->pfs), frame->my_bsp);
! info = __build_ia64_frame_state (pc, frame, bsp, NULL);
if (frame->rp.loc_type == IA64_UNW_LOC_TYPE_NONE) /* We've finished. */
break;
}
--- 1439,1445 ----
--pc;
bsp = __calc_caller_bsp
((long)__get_real_reg_value (&frame->pfs), frame->my_bsp);
! info = __build_ia64_frame_state (pc, frame, bsp, frame->my_psp, NULL);
if (frame->rp.loc_type == IA64_UNW_LOC_TYPE_NONE) /* We've finished. */
break;
}
*************** ia64_backtrace_helper (void **array, voi
*** 1419,1424 ****
--- 1452,1458 ----
int
__ia64_backtrace (void **array, int size)
{
+ register void *stack_pointer __asm__("r12");
ia64_frame_state my_frame;
ia64_frame_state originator; /* For the context handler is in. */
void *bsp;
*************** __ia64_backtrace (void **array, int size
*** 1428,1438 ****
registers. */
__builtin_unwind_init ();
- label_ia64:
bsp = __builtin_ia64_bsp ();
! return ia64_backtrace_helper (array, &&label_ia64, &my_frame,
! &originator, bsp, size);
}
--- 1462,1471 ----
registers. */
__builtin_unwind_init ();
bsp = __builtin_ia64_bsp ();
! return ia64_backtrace_helper (array, &my_frame, &originator, bsp,
! stack_pointer, size);
}
*************** print_record (f, ptr)
*** 1482,1490 ****
ptr->record.r.grsave);
break;
case mem_stack_f:
- case mem_stack_v:
fprintf (f, "(P7) t = %d, size = %d", ptr->record.p.t,
ptr->record.p.size);
break;
case psp_gr:
case rp_gr:
--- 1515,1525 ----
ptr->record.r.grsave);
break;
case mem_stack_f:
fprintf (f, "(P7) t = %d, size = %d", ptr->record.p.t,
ptr->record.p.size);
+ break;
+ case mem_stack_v:
+ fprintf (f, "(P7) t = %d", ptr->record.p.t);
break;
case psp_gr:
case rp_gr:
More information about the Gcc-patches
mailing list