2002-05-04 Andrew Cagney <ac131313@redhat.com>
+ * frame.h (select_frame): Delete level parameter.
+ * stack.c (select_frame): Update. Use frame_relative_level to
+ obtain the frame's level.
+ (select_and_print_frame): Update call.
+ (select_frame_command): Ditto.
+ (up_silently_base): Ditto.
+ (down_silently_base): Ditto.
+ * ocd.c (ocd_start_remote): Ditto.
+ * remote-rdp.c (remote_rdp_open): Ditto.
+ * remote-mips.c (mips_initialize): Ditto.
+ (common_open): Ditto.
+ * remote-e7000.c (e7000_start_remote): Ditto.
+ * m3-nat.c (select_thread): Ditto.
+ * hppa-tdep.c (child_get_current_exception_event): Ditto.
+ (child_get_current_exception_event): Ditto.
+ * varobj.c (varobj_create): Ditto.
+ (varobj_update): Ditto.
+ (c_value_of_root): Ditto.
+ * tracepoint.c (finish_tfind_command): Ditto.
+ * corelow.c (core_open): Ditto.
+ * arch-utils.c (generic_prepare_to_proceed): Ditto.
+ * thread.c (info_threads_command): Ditto.
+ (switch_to_thread): Ditto.
+ * infrun.c (normal_stop): Ditto.
+ (restore_selected_frame): Ditto.
+ (restore_inferior_status): Ditto.
+ * breakpoint.c (insert_breakpoints): Ditto.
+ (watchpoint_check): Ditto.
+ (bpstat_stop_status): Ditto.
+ (do_enable_breakpoint): Ditto.
+ * blockframe.c (flush_cached_frames): Ditto.
+ (reinit_frame_cache): Ditto.
+
+2002-05-04 Andrew Cagney <ac131313@redhat.com>
+
* MAINTAINERS (Host/Native): Add Jason Thorpe as NetBSD
maintainer.
flush_cached_frames ();
registers_changed ();
stop_pc = wait_pc;
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
/* We return 1 to indicate that there is a breakpoint here,
so we need to step over it before continuing to avoid
obstack_init (&frame_cache_obstack);
current_frame = NULL; /* Invalidate cache */
- select_frame (NULL, -1);
+ select_frame (NULL);
annotate_frames_invalid ();
}
/* FIXME: The inferior_ptid test is wrong if there is a corefile. */
if (PIDGET (inferior_ptid) != 0)
{
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
}
fi = find_frame_addr_in_frame_chain (b->watchpoint_frame);
within_current_scope = (fi != NULL);
if (within_current_scope)
- select_frame (fi, -1);
+ select_frame (fi);
}
if (within_current_scope)
/* Restore the frame and level. */
if ((saved_frame != selected_frame) ||
(saved_level != frame_relative_level (selected_frame)))
- select_frame (saved_frame, saved_level);
+ select_frame (saved_frame);
if (val)
return_val = val; /* remember failure */
/* If we end up stopping, the current frame will get selected
in normal_stop. So this call to select_frame won't affect
the user. */
- select_frame (fr, -1);
+ select_frame (fr);
}
if (within_current_scope)
{
/* Need to select the frame, with all that implies
so that the conditions will have the right context. */
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
value_is_zero
= catch_errors (breakpoint_cond_eval, (b->cond),
"Error in testing breakpoint condition:\n",
save_selected_frame = selected_frame;
save_selected_frame_level = frame_relative_level (selected_frame);
- select_frame (fr, -1);
+ select_frame (fr);
}
value_free (bpt->val);
}
if (save_selected_frame_level >= 0)
- select_frame (save_selected_frame, save_selected_frame_level);
+ select_frame (save_selected_frame);
value_free_to_mark (mark);
}
if (modify_breakpoint_hook)
/* Now, set up the frame cache, and print the top of stack. */
flush_cached_frames ();
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame,
frame_relative_level (selected_frame), 1);
}
extern void show_stack_frame (struct frame_info *);
-extern void select_frame (struct frame_info *, int);
+extern void select_frame (struct frame_info *);
extern void record_selected_frame (CORE_ADDR *, int *);
if (level != 0)
return (struct exception_event_record *) NULL;
- select_frame (fi, -1);
+ select_frame (fi);
/* Read in the arguments */
/* __d_eh_notify_callback() is called with 3 arguments:
if (level != 0)
return (struct exception_event_record *) NULL;
- select_frame (fi, -1);
+ select_frame (fi);
throw_addr = fi->pc;
/* Go back to original (top) frame */
- select_frame (curr_frame, -1);
+ select_frame (curr_frame);
current_ex_event.kind = (enum exception_event_kind) event_kind;
current_ex_event.throw_sal = find_pc_line (throw_addr, 1);
if (!stop_stack_dummy)
{
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
/* Print current location without a level number, if
we have changed functions or hit a breakpoint.
Can't rely on restore_inferior_status because that only gets
called if we don't stop in the called function. */
stop_pc = read_pc ();
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
done:
return 0;
}
- select_frame (frame, fr->level);
+ select_frame (frame);
return (1);
}
frame. */
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
stop_pc = read_pc ();
flush_cached_frames ();
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
return KERN_SUCCESS;
registers_changed ();
stop_pc = read_pc ();
set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame, -1, 1);
buf[0] = OCD_LOG_FILE;
registers_changed ();
stop_pc = read_pc ();
set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame, -1, 1);
return 1;
mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
set_current_frame (create_new_frame (read_fp (), read_pc ()));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
/* Open a connection to the remote board. */
registers_changed ();
stop_pc = read_pc ();
set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame, -1, 1);
xfree (serial_port_name);
}
registers_changed ();
stop_pc = read_pc ();
set_current_frame (create_new_frame (read_fp (), stop_pc));
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
print_stack_frame (selected_frame, -1, 1);
}
}
\f
-/* Select frame FI, and note that its stack level is LEVEL.
- LEVEL may be -1 if an actual level number is not known. */
+/* Select frame FI (or NULL - to invalidate the current frame). */
void
-select_frame (struct frame_info *fi, int level)
+select_frame (struct frame_info *fi)
{
register struct symtab *s;
selected_frame = fi;
- /* FIXME: cagney/2002-04-05: It can't be this easy (and looking at
- the increasingly complex list of checkes, it wasn't)! GDB is
- dragging around, and constantly updating, the global variable
- selected_frame_level. Surely all that was needed was for the
- level to be computed direct from the frame (by counting back to
- the inner-most frame) or, as has been done here using a cached
- value. For moment, check that the expected and the actual level
- are consistent. If, after a few weeks, no one reports that this
- assertion has failed, the global selected_frame_level and many
- many parameters can all be deleted. */
- if (fi == NULL && level == -1)
- /* Ok. The target is clearing the selected frame as part of a
- cache flush. */
- ;
- else if (fi != NULL && fi->level == level)
- /* Ok. What you would expect. Level is redundant. */
- ;
- else if (fi != NULL && level == -1)
- /* Ok. See breakpoint.c. The watchpoint code changes the
- selected frame to the frame that contains the watchpoint and
- then, later changes it back to the old value. The -1 is used
- as a marker so that the watchpoint code can easily detect that
- things are not what they should be. Why the watchpoint code
- can't mindlessly save/restore the selected frame I don't know,
- hopefully it can be simplified that way. Hopefully the global
- selected_frame can be replaced by a frame parameter, making
- still more simplification possible. */
- ;
- else
- internal_error (__FILE__, __LINE__,
- "Conflicting frame levels fi->level=%d, level=%d",
- (fi ? fi->level : -1),
- level);
+ /* NOTE: cagney/2002-05-04: FI can be NULL. This occures when the
+ frame is being invalidated. */
if (selected_frame_level_changed_hook)
- selected_frame_level_changed_hook (level);
+ selected_frame_level_changed_hook (frame_relative_level (fi));
/* Ensure that symbols for this frame are read in. Also, determine the
source language of this frame, and switch to it if desired. */
}
\f
-/* Select frame FI, noting that its stack level is LEVEL. Also print
- the stack frame and show the source if this is the tui version. */
+/* Select frame FI. Also print the stack frame and show the source if
+ this is the tui version. */
void
select_and_print_frame (struct frame_info *fi, int level)
{
- select_frame (fi, level);
+ select_frame (fi);
if (fi)
{
print_stack_frame (fi, level, 1);
if (!frame1)
level = 0;
- select_frame (frame, level);
+ select_frame (frame);
}
/* The "frame" command. With no arg, print selected frame briefly.
fi = find_relative_frame (selected_frame, &count1);
if (count1 != 0 && count_exp == 0)
error ("Initial frame selected; you cannot go up.");
- select_frame (fi, frame_relative_level (selected_frame) + count - count1);
+ select_frame (fi);
}
static void
error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
}
- select_frame (frame, frame_relative_level (selected_frame) + count - count1);
+ select_frame (frame);
}
/* ARGSUSED */
}
else
{
- select_frame (cur_frame, saved_frame_level);
+ select_frame (cur_frame);
}
/* re-show current frame. */
flush_cached_frames ();
registers_changed ();
stop_pc = read_pc ();
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
}
static void
flush_cached_frames ();
registers_changed ();
- select_frame (get_current_frame (), 0);
+ select_frame (get_current_frame ());
set_traceframe_num (target_frameno);
set_tracepoint_num (target_tracept);
if (target_frameno == -1)
{
var->root->frame = FRAME_FP (fi);
old_fi = selected_frame;
- select_frame (fi, -1);
+ select_frame (fi);
}
/* We definitively need to catch errors here.
/* Reset the selected frame */
if (fi != NULL)
- select_frame (old_fi, -1);
+ select_frame (old_fi);
}
/* If the variable object name is null, that means this
}
/* Restore selected frame */
- select_frame (old_fi, -1);
+ select_frame (old_fi);
if (type_changed)
return -2;
within_scope = fi != NULL;
/* FIXME: select_frame could fail */
if (within_scope)
- select_frame (fi, -1);
+ select_frame (fi);
}
if (within_scope)