- Remove unapplied: gdb-6.8-inlining-addon.patch
gdb-6.8-inlining-by-name.patch
This commit is contained in:
parent
0b181c5698
commit
8150eb3b6a
|
@ -1,571 +0,0 @@
|
|||
infcall.c <unwind_on_signal_p>:
|
||||
Revert the change of: gdb-6.8-inlining.patch
|
||||
causing: FAIL: gdb.base/unwindonsignal.exp: unwindonsignal, stack unwound
|
||||
|
||||
resume() -> target_resume() move of clear_inline_frame_state() is for:
|
||||
gdb.mi/mi-nsmoribund.exp
|
||||
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-bt.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-bt.c 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-bt.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -13,10 +13,16 @@
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
-int x, y;
|
||||
+/* VOLATILE forces all the inlining to happen as otherwise the whole program
|
||||
+ gets optimized by CSE to just simple assignments of the results. */
|
||||
+volatile int x, y;
|
||||
volatile int result;
|
||||
|
||||
-void bar(void);
|
||||
+inline void bar(void)
|
||||
+{
|
||||
+ x += y; /* set breakpoint 1 here */
|
||||
+}
|
||||
+
|
||||
|
||||
inline int func1(void)
|
||||
{
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-cmds.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-cmds.c 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-cmds.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -13,13 +13,19 @@
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
-int x, y;
|
||||
+/* VOLATILE forces all the inlining to happen as otherwise the whole program
|
||||
+ gets optimized by CSE to just simple assignments of the results. */
|
||||
+volatile int x, y;
|
||||
volatile int result;
|
||||
|
||||
-void bar(void);
|
||||
void marker(void);
|
||||
void noinline(void);
|
||||
|
||||
+inline void bar(void)
|
||||
+{
|
||||
+ x += y; /* set breakpoint 1 here */
|
||||
+}
|
||||
+
|
||||
inline int func1(void)
|
||||
{
|
||||
bar ();
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-cmds.exp
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-cmds.exp 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-cmds.exp 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -230,7 +230,7 @@ set line3 [gdb_get_line_number "set brea
|
||||
gdb_breakpoint $line3
|
||||
gdb_continue_to_breakpoint "consecutive func1"
|
||||
|
||||
-gdb_test "next" ".*func1 .*first call.*" "next to first func1"
|
||||
+gdb_test "next" "func1 .*first call.*" "next to first func1"
|
||||
set msg "next to second func1"
|
||||
gdb_test_multiple "next" $msg {
|
||||
-re ".*func1 .*second call.*$gdb_prompt $" {
|
||||
@@ -253,16 +253,16 @@ set line4 [gdb_get_line_number "set brea
|
||||
gdb_breakpoint $line4
|
||||
gdb_continue_to_breakpoint "func1 then func3"
|
||||
|
||||
-gdb_test "next" ".*func1 \\\(\\\);" "next to func1 before func3"
|
||||
-gdb_test "next" ".*func3 \\\(\\\);" "next to func3"
|
||||
+gdb_test "next" "func1 \\\(\\\);" "next to func1 before func3"
|
||||
+gdb_test "next" "func3 \\\(\\\);" "next to func3"
|
||||
|
||||
# Test finishing out of one thing and into another.
|
||||
set line5 [gdb_get_line_number "set breakpoint 5 here"]
|
||||
gdb_breakpoint $line5
|
||||
gdb_continue_to_breakpoint "finish into func1"
|
||||
|
||||
-gdb_test "next" ".*marker \\\(\\\);" "next to finish marker"
|
||||
-gdb_test "step" ".*set breakpoint 2 here.*" "step into finish marker"
|
||||
+gdb_test "next" "marker \\\(\\\);" "next to finish marker"
|
||||
+gdb_test "step" "set breakpoint 2 here.*" "step into finish marker"
|
||||
gdb_test "finish" "func1 \\\(\\\);" "finish from marker to func1"
|
||||
|
||||
gdb_test "step" "bar \\\(\\\);" "step into func1 for finish"
|
||||
@@ -297,12 +297,12 @@ gdb_test "step" "noinline \\\(\\\) at .*
|
||||
gdb_test "bt" "#0 noinline.*#1 .*outer_inline1.*#2 .*outer_inline2.*#3 main.*" "backtrace at noinline from outer_inline1"
|
||||
gdb_test "step" "inlined_fn \\\(\\\) at .*" "enter inlined_fn from noinline"
|
||||
gdb_test "bt" "#0 inlined_fn.*#1 noinline.*#2 .*outer_inline1.*#3 .*outer_inline2.*#4 main.*" "backtrace at inlined_fn from noinline"
|
||||
-gdb_test "info frame" ".*inlined into frame.*" "inlined_fn from noinline inlined"
|
||||
-gdb_test "up" "#1 noinline.*" "up to noinline"
|
||||
-gdb_test "info frame" ".*\n called by frame.*" "noinline from outer_inline1 not inlined"
|
||||
-gdb_test "up" "#2 .*outer_inline1.*" "up to outer_inline1"
|
||||
-gdb_test "info frame" ".*inlined into frame.*" "outer_inline1 inlined"
|
||||
-gdb_test "up" "#3 .*outer_inline2.*" "up to outer_inline2"
|
||||
-gdb_test "info frame" ".*inlined into frame.*" "outer_inline2 inlined"
|
||||
-gdb_test "up" "#4 main.*" "up from outer_inline2"
|
||||
-gdb_test "info frame" ".*\n caller of frame.*" "main not inlined"
|
||||
+gdb_test "info frame" "inlined into frame.*" "inlined_fn from noinline inlined"
|
||||
+gdb_test "fini" "" "up to noinline"
|
||||
+gdb_test "info frame" "\n called by frame.*" "noinline from outer_inline1 not inlined"
|
||||
+gdb_test "fini" "" "up to outer_inline1"
|
||||
+gdb_test "info frame" "inlined into frame.*" "outer_inline1 inlined"
|
||||
+gdb_test "fini" "" "up to outer_inline2"
|
||||
+gdb_test "info frame" "inlined into frame.*" "outer_inline2 inlined"
|
||||
+gdb_test "fini" "" "up from outer_inline2"
|
||||
+gdb_test "info frame" " in main \[^\n\]*\n source language.*" "main not inlined"
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-locals.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-locals.c 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-locals.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -13,11 +13,16 @@
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||||
|
||||
-int x, y;
|
||||
+/* VOLATILE forces all the inlining to happen as otherwise the whole program
|
||||
+ gets optimized by CSE to just simple assignments of the results. */
|
||||
+volatile int x, y;
|
||||
volatile int result;
|
||||
volatile int *array_p;
|
||||
|
||||
-void bar(void);
|
||||
+inline void bar(void)
|
||||
+{
|
||||
+ x += y; /* set breakpoint 1 here */
|
||||
+}
|
||||
|
||||
inline int func1(int arg1)
|
||||
{
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-locals.exp
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-locals.exp 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-locals.exp 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -77,6 +77,9 @@ if { ! $no_frames } {
|
||||
|
||||
# Make sure that locals on the stack are found. This is an array to
|
||||
# prevent it from living in a register.
|
||||
+if [test_compiler_info "gcc-4-3-*"] {
|
||||
+ setup_kfail *-*-* "gcc/debug.optimization"
|
||||
+}
|
||||
gdb_test "print array\[0\]" "\\\$$decimal = 0" "print local (2)"
|
||||
|
||||
if { ! $no_frames } {
|
||||
@@ -115,4 +118,7 @@ if { ! $no_frames } {
|
||||
gdb_test "info locals" ".*arg2 = 184.*" "info locals above bar (3b)"
|
||||
}
|
||||
|
||||
+if [test_compiler_info "gcc-4-3-*"] {
|
||||
+ setup_kfail *-*-* "gcc/debug.optimization"
|
||||
+}
|
||||
gdb_test "print array\[0\]" "\\\$$decimal = 184" "print local (3)"
|
||||
Index: gdb-7.0.50.20100121/gdb/frame.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/frame.c 2010-01-21 15:13:26.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/frame.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -316,7 +316,7 @@ fprint_frame (struct ui_file *file, stru
|
||||
static struct frame_info *
|
||||
skip_inlined_frames (struct frame_info *frame)
|
||||
{
|
||||
- while (get_frame_type (frame) == INLINE_FRAME)
|
||||
+ while (frame && get_frame_type (frame) == INLINE_FRAME)
|
||||
frame = get_prev_frame (frame);
|
||||
|
||||
return frame;
|
||||
@@ -1792,6 +1792,7 @@ get_frame_address_in_block (struct frame
|
||||
{
|
||||
/* A draft address. */
|
||||
CORE_ADDR pc = get_frame_pc (this_frame);
|
||||
+ struct thread_info *tp = inferior_thread ();
|
||||
|
||||
struct frame_info *next_frame = this_frame->next;
|
||||
|
||||
@@ -1834,6 +1835,9 @@ get_frame_address_in_block (struct frame
|
||||
while in an inlined function, then the code address of the
|
||||
"calling" normal function should not be adjusted either. */
|
||||
|
||||
+ if (tp->current_pc_is_notcurrent)
|
||||
+ return pc - 1;
|
||||
+
|
||||
while (get_frame_type (next_frame) == INLINE_FRAME)
|
||||
next_frame = next_frame->next;
|
||||
|
||||
@@ -1865,7 +1869,7 @@ find_frame_sal (struct frame_info *frame
|
||||
sym = inline_skipped_symbol (inferior_ptid);
|
||||
|
||||
init_sal (sal);
|
||||
- if (SYMBOL_LINE (sym) != 0)
|
||||
+ if (sym != NULL && SYMBOL_LINE (sym) != 0)
|
||||
{
|
||||
sal->symtab = SYMBOL_SYMTAB (sym);
|
||||
sal->line = SYMBOL_LINE (sym);
|
||||
Index: gdb-7.0.50.20100121/gdb/breakpoint.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/breakpoint.c 2010-01-21 15:14:41.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/breakpoint.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -62,6 +62,7 @@
|
||||
#include "jit.h"
|
||||
#include "xml-syscall.h"
|
||||
#include "parser-defs.h"
|
||||
+#include "inline-frame.h"
|
||||
|
||||
/* readline include files */
|
||||
#include "readline/readline.h"
|
||||
@@ -3558,10 +3559,24 @@ bpstat_check_breakpoint_conditions (bpst
|
||||
const struct bp_location *bl = bs->breakpoint_at;
|
||||
struct breakpoint *b = bl->owner;
|
||||
|
||||
- if (frame_id_p (b->frame_id)
|
||||
- && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
|
||||
- bs->stop = 0;
|
||||
- else if (bs->stop)
|
||||
+ if (frame_id_p (b->frame_id))
|
||||
+ {
|
||||
+ struct frame_info *b_frame, *frame;
|
||||
+ struct frame_id b_frame_id, current_frame_id;
|
||||
+
|
||||
+ b_frame = frame_find_by_id (b->frame_id);
|
||||
+
|
||||
+ /* get_stack_frame_id normalizes the id to the real non-inlined function
|
||||
+ by skip_inlined_frames. */
|
||||
+ b_frame_id = get_stack_frame_id (b_frame);
|
||||
+ current_frame_id = get_stack_frame_id (get_current_frame ());
|
||||
+
|
||||
+ /* Completely different (inlining notwithstanding) frames? */
|
||||
+ if (!frame_id_eq (b_frame_id, current_frame_id))
|
||||
+ bs->stop = 0;
|
||||
+ }
|
||||
+
|
||||
+ if (bs->stop)
|
||||
{
|
||||
int value_is_zero = 0;
|
||||
|
||||
@@ -3729,6 +3744,12 @@ bpstat_stop_status (struct address_space
|
||||
bs->print = 0;
|
||||
}
|
||||
bs->commands = copy_command_lines (bs->commands);
|
||||
+
|
||||
+ /* Display the innermost inlined frame at a breakpont as it gives to
|
||||
+ most of the available information. */
|
||||
+ if (b->type != bp_until && b->type != bp_finish)
|
||||
+ while (inline_skipped_frames (ptid))
|
||||
+ step_into_inline_frame (ptid);
|
||||
}
|
||||
|
||||
/* Print nothing for this entry if we dont stop or dont print. */
|
||||
@@ -6043,9 +6064,9 @@ set_momentary_breakpoint (struct gdbarch
|
||||
{
|
||||
struct breakpoint *b;
|
||||
|
||||
- /* If FRAME_ID is valid, it should be a real frame, not an inlined
|
||||
- one. */
|
||||
- gdb_assert (!frame_id_inlined_p (frame_id));
|
||||
+ /* We can be returning even into an inline frame. While finish_command will
|
||||
+ shortcut the case of returning _from_ an inline frame we still may be
|
||||
+ returning from non-inlined frame _to_ an inlined frame. */
|
||||
|
||||
b = set_raw_breakpoint (gdbarch, sal, type);
|
||||
b->enable_state = bp_enabled;
|
||||
Index: gdb-7.0.50.20100121/gdb/inline-frame.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/inline-frame.c 2010-01-01 08:31:36.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/inline-frame.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -213,6 +213,12 @@ inline_frame_sniffer (const struct frame
|
||||
if (frame_block == NULL)
|
||||
return 0;
|
||||
|
||||
+ /* For >=2 inlined functions SKIPPED_SYMBOL needs to be different after each
|
||||
+ step_into_inline_frame call. But skip_inline_frames is called only once
|
||||
+ and thus SKIPPED_SYMBOL needs to be calculated by INLINE_FRAME_SNIFFER. */
|
||||
+ if (state)
|
||||
+ state->skipped_symbol = NULL;
|
||||
+
|
||||
/* Calculate DEPTH, the number of inlined functions at this
|
||||
location. */
|
||||
depth = 0;
|
||||
@@ -222,6 +228,10 @@ inline_frame_sniffer (const struct frame
|
||||
if (block_inlined_p (cur_block))
|
||||
depth++;
|
||||
|
||||
+ if (state && depth == state->skipped_frames
|
||||
+ && state->skipped_symbol == NULL)
|
||||
+ state->skipped_symbol = BLOCK_FUNCTION (cur_block);
|
||||
+
|
||||
cur_block = BLOCK_SUPERBLOCK (cur_block);
|
||||
}
|
||||
|
||||
@@ -300,7 +310,6 @@ skip_inline_frames (ptid_t ptid)
|
||||
{
|
||||
CORE_ADDR this_pc;
|
||||
struct block *frame_block, *cur_block;
|
||||
- struct symbol *last_sym = NULL;
|
||||
int skip_count = 0;
|
||||
struct inline_state *state;
|
||||
|
||||
@@ -321,10 +330,7 @@ skip_inline_frames (ptid_t ptid)
|
||||
of BLOCK_START. */
|
||||
if (BLOCK_START (cur_block) == this_pc
|
||||
|| block_starting_point_at (this_pc, cur_block))
|
||||
- {
|
||||
- skip_count++;
|
||||
- last_sym = BLOCK_FUNCTION (cur_block);
|
||||
- }
|
||||
+ skip_count++;
|
||||
else
|
||||
break;
|
||||
}
|
||||
@@ -336,7 +342,6 @@ skip_inline_frames (ptid_t ptid)
|
||||
state = allocate_inline_frame_state (ptid);
|
||||
state->skipped_frames = skip_count;
|
||||
state->saved_pc = this_pc;
|
||||
- state->skipped_symbol = last_sym;
|
||||
|
||||
if (skip_count != 0)
|
||||
reinit_frame_cache ();
|
||||
@@ -354,6 +359,23 @@ step_into_inline_frame (ptid_t ptid)
|
||||
reinit_frame_cache ();
|
||||
}
|
||||
|
||||
+/* Step out of an inlined function by hiding it. */
|
||||
+
|
||||
+void
|
||||
+step_out_of_inline_frame (ptid_t ptid)
|
||||
+{
|
||||
+ struct inline_state *state = find_inline_frame_state (ptid);
|
||||
+
|
||||
+ gdb_assert (state != NULL);
|
||||
+
|
||||
+ /* Simulate the caller adjustment. */
|
||||
+ if (state->skipped_frames == 0)
|
||||
+ state->saved_pc--;
|
||||
+
|
||||
+ state->skipped_frames++;
|
||||
+ reinit_frame_cache ();
|
||||
+}
|
||||
+
|
||||
/* Return the number of hidden functions inlined into the current
|
||||
frame. */
|
||||
|
||||
Index: gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-markers.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/testsuite/gdb.opt/inline-markers.c 2010-01-01 08:32:04.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/testsuite/gdb.opt/inline-markers.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -15,11 +15,6 @@
|
||||
|
||||
extern int x, y;
|
||||
|
||||
-void bar(void)
|
||||
-{
|
||||
- x += y; /* set breakpoint 1 here */
|
||||
-}
|
||||
-
|
||||
void marker(void)
|
||||
{
|
||||
x += y; /* set breakpoint 2 here */
|
||||
Index: gdb-7.0.50.20100121/gdb/gdbthread.h
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/gdbthread.h 2010-01-21 15:11:09.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/gdbthread.h 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -195,6 +195,12 @@ struct thread_info
|
||||
/* Function that is called to free PRIVATE. If this is NULL, then
|
||||
xfree will be called on PRIVATE. */
|
||||
void (*private_dtor) (struct private_thread_info *);
|
||||
+
|
||||
+ /* Nonzero if the current frame PC should be unwound as the caller. It is
|
||||
+ used to keep the backtrace upper levels existing after finish_command into
|
||||
+ an inlined frame if the current inlined function/block was ending at the
|
||||
+ current PC. */
|
||||
+ int current_pc_is_notcurrent;
|
||||
};
|
||||
|
||||
/* Create an empty thread list, or empty the existing one. */
|
||||
Index: gdb-7.0.50.20100121/gdb/infcmd.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/infcmd.c 2010-01-21 15:11:09.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/infcmd.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -1439,11 +1439,11 @@ finish_command_continuation (void *arg)
|
||||
struct type *value_type;
|
||||
|
||||
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (a->function));
|
||||
- if (!value_type)
|
||||
+ if (!SYMBOL_INLINED (a->function) && !value_type)
|
||||
internal_error (__FILE__, __LINE__,
|
||||
_("finish_command: function has no target type"));
|
||||
|
||||
- if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
|
||||
+ if (value_type && TYPE_CODE (value_type) != TYPE_CODE_VOID)
|
||||
print_return_value (SYMBOL_TYPE (a->function), value_type);
|
||||
}
|
||||
|
||||
@@ -1551,6 +1551,16 @@ finish_forward (struct symbol *function,
|
||||
tp->initiating_frame = get_frame_id (frame);
|
||||
make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
|
||||
|
||||
+ /* We should _always_ set CURRENT_PC_IS_NOTCURRENT here to always see the
|
||||
+ calling line with the message `Value returned is ...'. Currently it is
|
||||
+ seen only if at least one instruction is on that source line after the
|
||||
+ call instruction. We would also need to hook step_once and only clear
|
||||
+ CURRENT_PC_IS_NOTCURRENT on the first step. But it would be a change of
|
||||
+ general non-inlining behavior against upstream. */
|
||||
+
|
||||
+ if (get_frame_type (frame) == INLINE_FRAME)
|
||||
+ tp->current_pc_is_notcurrent = 1;
|
||||
+
|
||||
tp->proceed_to_finish = 1; /* We want stop_registers, please... */
|
||||
cargs = xmalloc (sizeof (*cargs));
|
||||
|
||||
@@ -1571,7 +1581,9 @@ finish_forward (struct symbol *function,
|
||||
static void
|
||||
finish_command (char *arg, int from_tty)
|
||||
{
|
||||
- struct frame_info *frame;
|
||||
+ /* FIXME: Rename `current_frame' to `frame' upon a merge. */
|
||||
+ struct frame_info *current_frame, *prev_frame;
|
||||
+ CORE_ADDR frame_pc;
|
||||
struct symbol *function;
|
||||
|
||||
int async_exec = 0;
|
||||
@@ -1602,45 +1614,63 @@ finish_command (char *arg, int from_tty)
|
||||
if (!target_has_execution)
|
||||
error (_("The program is not running."));
|
||||
|
||||
- frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
|
||||
- if (frame == 0)
|
||||
+ current_frame = get_selected_frame (_("No selected frame."));
|
||||
+ frame_pc = get_frame_pc (current_frame);
|
||||
+ prev_frame = get_prev_frame (current_frame);
|
||||
+ if (prev_frame == 0)
|
||||
error (_("\"finish\" not meaningful in the outermost frame."));
|
||||
|
||||
- clear_proceed_status ();
|
||||
-
|
||||
/* Finishing from an inline frame is completely different. We don't
|
||||
try to show the "return value" - no way to locate it. So we do
|
||||
not need a completion. */
|
||||
- if (get_frame_type (get_selected_frame (_("No selected frame.")))
|
||||
- == INLINE_FRAME)
|
||||
+ if (get_frame_type (current_frame) == INLINE_FRAME)
|
||||
{
|
||||
- /* Claim we are stepping in the calling frame. An empty step
|
||||
- range means that we will stop once we aren't in a function
|
||||
- called by that frame. We don't use the magic "1" value for
|
||||
- step_range_end, because then infrun will think this is nexti,
|
||||
- and not step over the rest of this inlined function call. */
|
||||
struct thread_info *tp = inferior_thread ();
|
||||
struct symtab_and_line empty_sal;
|
||||
- init_sal (&empty_sal);
|
||||
- set_step_info (frame, empty_sal);
|
||||
- tp->step_range_start = tp->step_range_end = get_frame_pc (frame);
|
||||
- tp->step_over_calls = STEP_OVER_ALL;
|
||||
+ struct block *frame_block;
|
||||
|
||||
/* Print info on the selected frame, including level number but not
|
||||
source. */
|
||||
if (from_tty)
|
||||
{
|
||||
printf_filtered (_("Run till exit from "));
|
||||
- print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
|
||||
+ print_stack_frame (current_frame, 1, LOCATION);
|
||||
+ }
|
||||
+
|
||||
+ /* Even just a single stepi would get us out of the caller function PC
|
||||
+ range. */
|
||||
+
|
||||
+ frame_block = get_frame_block (current_frame, NULL);
|
||||
+
|
||||
+ /* FRAME_BLOCK must be initialized and also the frame printing above must
|
||||
+ be done still with the original CURRENT_PC_IS_NOTCURRENT setting. */
|
||||
+ clear_proceed_status ();
|
||||
+
|
||||
+ if (frame_block && BLOCK_END (frame_block) == frame_pc)
|
||||
+ {
|
||||
+ step_out_of_inline_frame (tp->ptid);
|
||||
+ tp->current_pc_is_notcurrent = 1;
|
||||
+ normal_stop ();
|
||||
+ return;
|
||||
}
|
||||
|
||||
+ /* Claim we are stepping in the calling frame. An empty step
|
||||
+ range means that we will stop once we aren't in a function
|
||||
+ called by that frame. We don't use the magic "1" value for
|
||||
+ step_range_end, because then infrun will think this is nexti,
|
||||
+ and not step over the rest of this inlined function call. */
|
||||
+ init_sal (&empty_sal);
|
||||
+ set_step_info (prev_frame, empty_sal);
|
||||
+ tp->step_range_start = tp->step_range_end = get_frame_pc (prev_frame);
|
||||
+ tp->step_over_calls = STEP_OVER_ALL;
|
||||
+
|
||||
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Find the function we will return from. */
|
||||
|
||||
- function = find_pc_function (get_frame_pc (get_selected_frame (NULL)));
|
||||
+ function = find_pc_function (frame_pc);
|
||||
|
||||
/* Print info on the selected frame, including level number but not
|
||||
source. */
|
||||
@@ -1654,10 +1684,14 @@ finish_command (char *arg, int from_tty)
|
||||
print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
|
||||
}
|
||||
|
||||
+ /* Frames printing above must be done still with the original
|
||||
+ CURRENT_PC_IS_NOTCURRENT setting. */
|
||||
+ clear_proceed_status ();
|
||||
+
|
||||
if (execution_direction == EXEC_REVERSE)
|
||||
finish_backward (function);
|
||||
else
|
||||
- finish_forward (function, frame);
|
||||
+ finish_forward (function, prev_frame);
|
||||
}
|
||||
|
||||
|
||||
Index: gdb-7.0.50.20100121/gdb/target.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/target.c 2010-01-21 15:13:26.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/target.c 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -2216,6 +2216,7 @@ target_resume (ptid_t ptid, int step, en
|
||||
{
|
||||
struct target_ops *t;
|
||||
|
||||
+ clear_inline_frame_state (ptid);
|
||||
target_dcache_invalidate ();
|
||||
|
||||
for (t = current_target.beneath; t != NULL; t = t->beneath)
|
||||
Index: gdb-7.0.50.20100121/gdb/inline-frame.h
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/inline-frame.h 2010-01-01 08:31:36.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/inline-frame.h 2010-01-21 15:14:47.000000000 +0100
|
||||
@@ -43,6 +43,10 @@ void clear_inline_frame_state (ptid_t pt
|
||||
|
||||
void step_into_inline_frame (ptid_t ptid);
|
||||
|
||||
+/* Step out of an inlined function by hiding it. */
|
||||
+
|
||||
+void step_out_of_inline_frame (ptid_t ptid);
|
||||
+
|
||||
/* Return the number of hidden functions inlined into the current
|
||||
frame. */
|
||||
|
||||
Index: gdb-7.0.50.20100121/gdb/dwarf2read.c
|
||||
===================================================================
|
||||
--- gdb-7.0.50.20100121.orig/gdb/dwarf2read.c 2010-01-21 15:14:41.000000000 +0100
|
||||
+++ gdb-7.0.50.20100121/gdb/dwarf2read.c 2010-01-21 15:15:09.000000000 +0100
|
||||
@@ -4137,6 +4137,7 @@ read_func_scope (struct die_info *die, s
|
||||
struct block *block;
|
||||
unsigned die_children = 0;
|
||||
int inlined_func = (die->tag == DW_TAG_inlined_subroutine);
|
||||
+ struct type *type;
|
||||
|
||||
if (inlined_func)
|
||||
{
|
||||
@@ -4178,7 +4179,10 @@ read_func_scope (struct die_info *die, s
|
||||
add_to_cu_func_list (name, lowpc, highpc, cu);
|
||||
|
||||
new = push_context (0, lowpc);
|
||||
- new->name = new_symbol (die, read_type_die (die, cu), cu);
|
||||
+ type = read_type_die (die, cu);
|
||||
+ gdb_assert (type != NULL);
|
||||
+ new->name = new_symbol (die, type, cu);
|
||||
+ gdb_assert (TYPE_CODE (SYMBOL_TYPE (new->name)) == TYPE_CODE_FUNC);
|
||||
|
||||
/* If there is a location expression for DW_AT_frame_base, record
|
||||
it. */
|
|
@ -1,104 +0,0 @@
|
|||
Implement `b <funcname>' for <funcname> with concete inlined instances by
|
||||
a multiple-PC breakpoint.
|
||||
|
||||
Index: gdb-6.8.50.20081128/gdb/ada-lang.c
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/ada-lang.c 2008-11-25 00:21:15.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/ada-lang.c 2008-12-06 21:39:56.000000000 +0100
|
||||
@@ -4614,7 +4614,7 @@ remove_irrelevant_renamings (struct ada_
|
||||
if (current_block == NULL)
|
||||
return nsyms;
|
||||
|
||||
- current_function = block_linkage_function (current_block);
|
||||
+ current_function = block_function (current_block);
|
||||
if (current_function == NULL)
|
||||
return nsyms;
|
||||
|
||||
@@ -6625,7 +6625,7 @@ ada_find_renaming_symbol (const char *na
|
||||
static struct symbol *
|
||||
find_old_style_renaming_symbol (const char *name, struct block *block)
|
||||
{
|
||||
- const struct symbol *function_sym = block_linkage_function (block);
|
||||
+ const struct symbol *function_sym = block_function (block);
|
||||
char *rename;
|
||||
|
||||
if (function_sym != NULL)
|
||||
Index: gdb-6.8.50.20081128/gdb/block.c
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/block.c 2008-12-06 14:06:16.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/block.c 2008-12-06 21:40:29.000000000 +0100
|
||||
@@ -75,6 +75,19 @@ block_linkage_function (const struct blo
|
||||
return BLOCK_FUNCTION (bl);
|
||||
}
|
||||
|
||||
+/* Return the symbol for the function which contains a specified
|
||||
+ lexical block, described by a struct block BL. Inlined functions
|
||||
+ can be returned. */
|
||||
+
|
||||
+struct symbol *
|
||||
+block_function (const struct block *bl)
|
||||
+{
|
||||
+ while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
|
||||
+ bl = BLOCK_SUPERBLOCK (bl);
|
||||
+
|
||||
+ return BLOCK_FUNCTION (bl);
|
||||
+}
|
||||
+
|
||||
/* Return one if BL represents an inlined function. */
|
||||
|
||||
int
|
||||
Index: gdb-6.8.50.20081128/gdb/block.h
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/block.h 2008-12-06 14:06:16.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/block.h 2008-12-06 21:39:56.000000000 +0100
|
||||
@@ -133,6 +133,7 @@ struct blockvector
|
||||
enum { GLOBAL_BLOCK = 0, STATIC_BLOCK = 1, FIRST_LOCAL_BLOCK = 2 };
|
||||
|
||||
extern struct symbol *block_linkage_function (const struct block *);
|
||||
+extern struct symbol *block_function (const struct block *bl);
|
||||
|
||||
extern int block_inlined_p (const struct block *block);
|
||||
|
||||
Index: gdb-6.8.50.20081128/gdb/blockframe.c
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/blockframe.c 2008-12-06 14:06:16.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/blockframe.c 2008-12-06 21:39:56.000000000 +0100
|
||||
@@ -143,7 +143,7 @@ find_pc_sect_function (CORE_ADDR pc, str
|
||||
struct block *b = block_for_pc_sect (pc, section);
|
||||
if (b == 0)
|
||||
return 0;
|
||||
- return block_linkage_function (b);
|
||||
+ return block_function (b);
|
||||
}
|
||||
|
||||
/* Return the function containing pc value PC.
|
||||
Index: gdb-6.8.50.20081128/gdb/breakpoint.c
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/breakpoint.c 2008-12-06 14:06:17.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/breakpoint.c 2008-12-06 21:39:56.000000000 +0100
|
||||
@@ -5712,7 +5712,7 @@ resolve_sal_pc (struct symtab_and_line *
|
||||
bv = blockvector_for_pc_sect (sal->pc, 0, &b, sal->symtab);
|
||||
if (bv != NULL)
|
||||
{
|
||||
- sym = block_linkage_function (b);
|
||||
+ sym = block_function (b);
|
||||
if (sym != NULL)
|
||||
{
|
||||
fixup_symbol_section (sym, sal->symtab->objfile);
|
||||
Index: gdb-6.8.50.20081128/gdb/testsuite/gdb.opt/inline-cmds.exp
|
||||
===================================================================
|
||||
--- gdb-6.8.50.20081128.orig/gdb/testsuite/gdb.opt/inline-cmds.exp 2008-12-06 21:37:27.000000000 +0100
|
||||
+++ gdb-6.8.50.20081128/gdb/testsuite/gdb.opt/inline-cmds.exp 2008-12-06 21:41:37.000000000 +0100
|
||||
@@ -45,8 +45,10 @@ if { [skip_inline_frame_tests] } {
|
||||
|
||||
# First, check that the things we expected to be inlined really were,
|
||||
# and those that shouldn't be weren't.
|
||||
-set line1 [gdb_get_line_number "set breakpoint 1 here" ${srcfile2}]
|
||||
-gdb_breakpoint $srcfile2:$line1
|
||||
+# We test also inlining by the function name, otherwise we would use:
|
||||
+# set line1 [gdb_get_line_number "set breakpoint 1 here" ${srcfile2}]
|
||||
+# gdb_breakpoint $srcfile2:$line1
|
||||
+gdb_breakpoint "bar"
|
||||
set line2 [gdb_get_line_number "set breakpoint 2 here" ${srcfile2}]
|
||||
gdb_breakpoint $srcfile2:$line2
|
||||
|
17
gdb.spec
17
gdb.spec
|
@ -36,7 +36,7 @@ Version: 7.0.90.20100306
|
|||
|
||||
# The release always contains a leading reserved number, start it at 1.
|
||||
# `upstream' is not a part of `name' to stay fully rpm dependencies compatible for the testing.
|
||||
Release: 19%{?_with_upstream:.upstream}%{dist}
|
||||
Release: 20%{?_with_upstream:.upstream}%{dist}
|
||||
|
||||
License: GPLv3+
|
||||
Group: Development/Debuggers
|
||||
|
@ -345,13 +345,6 @@ Patch324: gdb-6.8-glibc-headers-compat.patch
|
|||
# Create a single binary `gdb' autodetecting --tui by its argv[0].
|
||||
Patch326: gdb-6.8-tui-singlebinary.patch
|
||||
|
||||
# Support transparent debugging of inlined functions for an optimized code.
|
||||
# Disable break-by-name on inlined functions due to a regression on parameters
|
||||
# of inlined functions falsely <optimized out> (BZ 556975 Comment 8).
|
||||
# Disable addon (finish) due to inline-cmds.exp: up from outer_inline2 assert.
|
||||
Patch350: gdb-6.8-inlining-addon.patch
|
||||
Patch328: gdb-6.8-inlining-by-name.patch
|
||||
|
||||
# Fix PRPSINFO in the core files dumped by gcore (BZ 254229).
|
||||
Patch329: gdb-6.8-bz254229-gcore-prpsinfo.patch
|
||||
|
||||
|
@ -544,7 +537,8 @@ GDB, the GNU debugger, allows you to debug programs written in C, C++,
|
|||
Java, and other languages, by executing them in a controlled fashion
|
||||
and printing their data.
|
||||
|
||||
This package provides a program that allows you to run GDB on a different machine than the one which is running the program being debugged.
|
||||
This package provides a program that allows you to run GDB on a different
|
||||
machine than the one which is running the program being debugged.
|
||||
%endif # 0%{!?el5:1}
|
||||
|
||||
%prep
|
||||
|
@ -657,8 +651,6 @@ rm -f gdb/jv-exp.c gdb/m2-exp.c gdb/objc-exp.c gdb/p-exp.c
|
|||
%patch322 -p1
|
||||
%patch324 -p1
|
||||
%patch326 -p1
|
||||
###patch350 -p1
|
||||
###patch328 -p1
|
||||
%patch329 -p1
|
||||
%patch330 -p1
|
||||
%patch331 -p1
|
||||
|
@ -1017,6 +1009,9 @@ fi
|
|||
%endif
|
||||
|
||||
%changelog
|
||||
* Mon Mar 8 2010 Jan Kratochvil <jan.kratochvil@redhat.com> - 7.0.90.20100306-20.fc13
|
||||
- Remove unapplied: gdb-6.8-inlining-addon.patch gdb-6.8-inlining-by-name.patch
|
||||
|
||||
* Mon Mar 8 2010 Jan Kratochvil <jan.kratochvil@redhat.com> - 7.0.90.20100306-19.fc13
|
||||
- Include also %%doc COPYING3 (review by Petr Machata).
|
||||
- Remove URL for Source (review by Matej Cepl).
|
||||
|
|
Loading…
Reference in New Issue