[commit, 6.0] Add frame_unwind_address_in_block

[Andrew Cagney <ac131313 at redhat dot com>]

Hello,

This patch adds the function pair:
	frame_unwind_address_in_block
	get_frame_address_in_block
as successors to:
	frame_address_in_block
The new methods are more correct (they handle dummy as well as sigtramp 
frames) and follow a consistent nameing schema.

The expectation is that frame sniffers will use 
frame_unwind_address_in_block as a way of obtaining a PC that falls 
within the function.

A follow on patch will switch the mainline to get_frame_address_in_block 
while the 6.0 branch will be left as-is.

committed to 6.0 and the mainline
Andrew

2003-07-11  Andrew Cagney  <cagney@redhat.com>

	* frame.h (get_frame_address_in_block): Declare.
	(frame_unwind_address_in_block): Declare.
	* frame.c (frame_unwind_address_in_block): New function.
	(get_frame_address_in_block): New function.

Index: frame.c
===================================================================
RCS file: /cvs/src/src/gdb/frame.c,v
retrieving revision 1.130
diff -u -r1.130 frame.c
--- frame.c	7 Jul 2003 20:07:12 -0000	1.130
+++ frame.c	11 Jul 2003 14:42:37 -0000
@@ -2006,6 +2006,33 @@
   return frame_pc_unwind (frame->next);
 }
 
+/* Return an address of that falls within the frame's code block.  */
+
+CORE_ADDR
+frame_unwind_address_in_block (struct frame_info *next_frame)
+{
+  /* A draft address.  */
+  CORE_ADDR pc = frame_pc_unwind (next_frame);
+
+  /* If THIS frame is not inner most (i.e., NEXT isn't the sentinel),
+     and NEXT is `normal' (i.e., not a sigtramp, dummy, ....) THIS
+     frame's PC ends up pointing at the instruction fallowing the
+     "call".  Adjust that PC value so that it falls on the call
+     instruction (which, hopefully, falls within THIS frame's code
+     block.  So far it's proved to be a very good approximation.  See
+     get_frame_type for why ->type can't be used.  */
+  if (next_frame->level >= 0
+      && get_frame_type (next_frame) == NORMAL_FRAME)
+    --pc;
+  return pc;
+}
+
+CORE_ADDR
+get_frame_address_in_block (struct frame_info *this_frame)
+{
+  return frame_unwind_address_in_block (this_frame->next);
+}
+
 static int
 pc_notcurrent (struct frame_info *frame)
 {
Index: frame.h
===================================================================
RCS file: /cvs/src/src/gdb/frame.h,v
retrieving revision 1.104
diff -u -r1.104 frame.h
--- frame.h	7 Jul 2003 14:36:58 -0000	1.104
+++ frame.h	11 Jul 2003 14:42:37 -0000
@@ -214,6 +214,22 @@
    This replaced: frame->pc; */
 extern CORE_ADDR get_frame_pc (struct frame_info *);
 
+/* An address (not necessarily alligned to an instruction boundary)
+   that falls within THIS frame's code block.
+
+   When a function call is the last statement in a block, the return
+   address for the call may land at the start of the next block.
+   Similarly, if a no-return function call is the last statement in
+   the function, the return address may end up pointing beyond the
+   function, and possibly at the start of the next function.
+
+   These methods make an allowance for this.  For call frames, this
+   function returns the frame's PC-1 which "should" be an address in
+   the frame's block.  */
+
+extern CORE_ADDR get_frame_address_in_block (struct frame_info *this_frame);
+extern CORE_ADDR frame_unwind_address_in_block (struct frame_info *next_frame);
+
 /* The frame's inner-most bound.  AKA the stack-pointer.  Confusingly
    known as top-of-stack.  */
 
@@ -526,6 +542,8 @@
 
 extern struct symbol *get_frame_function (struct frame_info *);
 
+/* DEPRECATED: Replaced by tye pair get_frame_address_in_block and
+   frame_unwind_address_in_block.  */
 extern CORE_ADDR frame_address_in_block (struct frame_info *);
 
 extern CORE_ADDR get_pc_function_start (CORE_ADDR);