mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 10:03:47 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Eliminate catch_exceptions/catch_exceptions_with_msg

Browse Source 
This patch gets rid of catch_exceptions / catch_exceptions_with_msg.
The latter is done mostly by getting rid of the three remaining
vestigial libgdb wrapper functions, which are really pointless
nowadays.  This results in a good number of simplifications.

(I checked that Insight doesn't use those functions.)

The gdb.mi/mi-pthreads.exp change is necessary because this actually
fixes a bug, IMO -- the patch stops MI's -thread-select causing output
on the CLI stream.

I.e., before:
 -thread-select 123456789
 &"Thread ID 123456789 not known.\n"
 ^error,msg="Thread ID 123456789 not known."
 (gdb)

After:
 -thread-select 123456789
 ^error,msg="Thread ID 123456789 not known."
 (gdb)

gdb/ChangeLog
2017-10-10  Pedro Alves <palves@redhat.com>
	    Tom Tromey  <tom@tromey.com>

	* breakpoint.c (struct captured_breakpoint_query_args)
	(do_captured_breakpoint_query, gdb_breakpoint_query): Delete.
	(print_breakpoint): New.
	* breakpoint.h (print_breakpoint): Declare.
	* common/common-exceptions.h (enum return_reason): Remove
	references to catch_exceptions.
	* exceptions.c (catch_exceptions, catch_exceptions_with_msg):
	Delete.
	* exceptions.h (catch_exceptions_ftype, catch_exceptions)
	(catch_exception_ftype, catch_exceptions_with_msg): Delete.
	* gdb.h: Delete.
	* gdbthread.h (thread_select): Declare.
	* mi/mi-cmd-break.c: Don't include gdb.h.
	(breakpoint_notify): Use print_breakpoint.
	* mi/mi-cmd-catch.c: Don't include gdb.h.
	* mi/mi-interp.c: Don't include gdb.h.
	(mi_print_breakpoint_for_event): New.
	(mi_breakpoint_created, mi_breakpoint_modified): Use
	mi_print_breakpoint_for_event.
	* mi/mi-main.c: Don't include gdb.h.
	(mi_cmd_thread_select): Parse the global thread ID here.  Use
	thread_select instead of gdb_thread_select.
	(mi_cmd_thread_list_ids): Output "thread-ids" tuple here instead
	of using gdb_list_thread_ids.
	* remote-fileio.c (do_remote_fileio_request): Change type.  Reply
	FILEIO_ENOSYS here.
	(remote_fileio_request): Use TRY/CATCH instead of
	catch_exceptions.
	* symfile-mem.c (struct symbol_file_add_from_memory_args)
	(symbol_file_add_from_memory_wrapper): Delete.
	(add_vsyscall_page): Use TRY/CATCH instead of catch_exceptions.
	* thread.c: Don't include gdb.h.
	(do_captured_list_thread_ids, gdb_list_thread_ids): Delete.
	(thread_alive): Use thread_select.
	(do_captured_thread_select): Delete, parts salvaged as ...
	(thread_select): ... this new function.
	(gdb_thread_select): Delete.

gdb/testsuite/ChangeLog
2017-10-10  Pedro Alves <palves@redhat.com>

	* gdb.mi/mi-pthreads.exp (check_mi_thread_command_set): Don't
	expect CLI output.
This commit is contained in:
Pedro Alves 2017-10-10 16:45:51 +01:00
parent bf46927112
commit 65630365f7
17 changed files with 174 additions and 425 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
gdb/ChangeLog
View File

@ -1,3 +1,44 @@
2017-10-10 Pedro Alves <palves@redhat.com>
Tom Tromey <tom@tromey.com>
* breakpoint.c (struct captured_breakpoint_query_args)
(do_captured_breakpoint_query, gdb_breakpoint_query): Delete.
(print_breakpoint): New.
* breakpoint.h (print_breakpoint): Declare.
* common/common-exceptions.h (enum return_reason): Remove
references to catch_exceptions.
* exceptions.c (catch_exceptions, catch_exceptions_with_msg):
Delete.
* exceptions.h (catch_exceptions_ftype, catch_exceptions)
(catch_exception_ftype, catch_exceptions_with_msg): Delete.
* gdb.h: Delete.
* gdbthread.h (thread_select): Declare.
* mi/mi-cmd-break.c: Don't include gdb.h.
(breakpoint_notify): Use print_breakpoint.
* mi/mi-cmd-catch.c: Don't include gdb.h.
* mi/mi-interp.c: Don't include gdb.h.
(mi_print_breakpoint_for_event): New.
(mi_breakpoint_created, mi_breakpoint_modified): Use
mi_print_breakpoint_for_event.
* mi/mi-main.c: Don't include gdb.h.
(mi_cmd_thread_select): Parse the global thread ID here. Use
thread_select instead of gdb_thread_select.
(mi_cmd_thread_list_ids): Output "thread-ids" tuple here instead
of using gdb_list_thread_ids.
* remote-fileio.c (do_remote_fileio_request): Change type. Reply
FILEIO_ENOSYS here.
(remote_fileio_request): Use TRY/CATCH instead of
catch_exceptions.
* symfile-mem.c (struct symbol_file_add_from_memory_args)
(symbol_file_add_from_memory_wrapper): Delete.
(add_vsyscall_page): Use TRY/CATCH instead of catch_exceptions.
* thread.c: Don't include gdb.h.
(do_captured_list_thread_ids, gdb_list_thread_ids): Delete.
(thread_alive): Use thread_select.
(do_captured_thread_select): Delete, parts salvaged as ...
(thread_select): ... this new function.
(gdb_thread_select): Delete.
2017-10-10 Pedro Alves <palves@redhat.com>
Tom Tromey <tom@tromey.com>

40
gdb/breakpoint.c
View File

@ -44,7 +44,6 @@
#include "source.h"
#include "linespec.h"
#include "completer.h"
#include "gdb.h"
#include "ui-out.h"
#include "cli/cli-script.h"
#include "block.h"
@ -6599,44 +6598,13 @@ breakpoint_address_bits (struct breakpoint *b)
return print_address_bits;
}
struct captured_breakpoint_query_args
{
int bnum;
};
/* See breakpoint.h. */
static int
do_captured_breakpoint_query (struct ui_out *uiout, void *data)
void
print_breakpoint (breakpoint *b)
{
struct captured_breakpoint_query_args *args
= (struct captured_breakpoint_query_args *) data;
struct breakpoint *b;
struct bp_location *dummy_loc = NULL;
ALL_BREAKPOINTS (b)
{
if (args->bnum == b->number)
{
print_one_breakpoint (b, &dummy_loc, 0);
return GDB_RC_OK;
}
}
return GDB_RC_NONE;
}
enum gdb_rc
gdb_breakpoint_query (struct ui_out *uiout, int bnum,
char **error_message)
{
struct captured_breakpoint_query_args args;
args.bnum = bnum;
/* For the moment we don't trust print_one_breakpoint() to not throw
an error. */
if (catch_exceptions_with_msg (uiout, do_captured_breakpoint_query, &args,
error_message, RETURN_MASK_ALL) < 0)
return GDB_RC_FAIL;
else
return GDB_RC_OK;
print_one_breakpoint (b, &dummy_loc, 0);
}
/* Return true if this breakpoint was set by the user, false if it is

3
gdb/breakpoint.h
View File

@ -1644,4 +1644,7 @@ extern const char *ep_parse_optional_if_clause (const char **arg);
UIOUT iff debugging multiple threads. */
extern void maybe_print_thread_hit_breakpoint (struct ui_out *uiout);
/* Print the specified breakpoint. */
extern void print_breakpoint (breakpoint *bp);
#endif /* !defined (BREAKPOINT_H) */

6
gdb/common/common-exceptions.h
View File

@ -24,10 +24,8 @@
#include <new>
/* Reasons for calling throw_exceptions(). NOTE: all reason values
must be less than zero. enum value 0 is reserved for internal use
as the return value from an initial setjmp(). The function
catch_exceptions() reserves values >= 0 as legal results from its
wrapped function. */
must be different from zero. enum value 0 is reserved for internal
use as the return value from an initial setjmp(). */
enum return_reason
{

83
gdb/exceptions.c
View File

@ -134,89 +134,6 @@ exception_fprintf (struct ui_file *file, struct gdb_exception e,
}
}
/* Call FUNC(UIOUT, FUNC_ARGS) but wrapped within an exception
handler. If an exception (enum return_reason) is thrown using
throw_exception() than all cleanups installed since
catch_exceptions() was entered are invoked, the (-ve) exception
value is then returned by catch_exceptions. If FUNC() returns
normally (with a positive or zero return value) then that value is
returned by catch_exceptions(). It is an internal_error() for
FUNC() to return a negative value.
See exceptions.h for further usage details. */
/* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
error() et al. could maintain a set of flags that indicate the
current state of each of the longjmp buffers. This would give the
longjmp code the chance to detect a longjmp botch (before it gets
to longjmperror()). Prior to 1999-11-05 this wasn't possible as
code also randomly used a SET_TOP_LEVEL macro that directly
initialized the longjmp buffers. */
int
catch_exceptions (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
return_mask mask)
{
return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask);
}
int
catch_exceptions_with_msg (struct ui_out *func_uiout,
catch_exceptions_ftype *func,
void *func_args,
char **gdberrmsg,
return_mask mask)
{
struct gdb_exception exception = exception_none;
volatile int val = 0;
struct ui_out *saved_uiout;
/* Save and override the global ``struct ui_out'' builder. */
saved_uiout = current_uiout;
current_uiout = func_uiout;
TRY
{
val = (*func) (current_uiout, func_args);
}
CATCH (ex, RETURN_MASK_ALL)
{
exception = ex;
}
END_CATCH
/* Restore the global builder. */
current_uiout = saved_uiout;
if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0)
{
/* The caller didn't request that the event be caught.
Rethrow. */
throw_exception (exception);
}
exception_print (gdb_stderr, exception);
gdb_assert (val >= 0);
gdb_assert (exception.reason <= 0);
if (exception.reason < 0)
{
/* If caller wants a copy of the low-level error message, make
one. This is used in the case of a silent error whereby the
caller may optionally want to issue the message. */
if (gdberrmsg != NULL)
{
if (exception.message != NULL)
*gdberrmsg = xstrdup (exception.message);
else
*gdberrmsg = NULL;
}
return exception.reason;
}
return val;
}
/* See exceptions.h. */
int

42
gdb/exceptions.h
View File

@ -29,48 +29,6 @@ extern void exception_fprintf (struct ui_file *file, struct gdb_exception e,
const char *prefix,
...) ATTRIBUTE_PRINTF (3, 4);
/* Call FUNC(UIOUT, FUNC_ARGS) but wrapped within an exception
handler. If an exception (enum return_reason) is thrown using
throw_exception() than all cleanups installed since
catch_exceptions() was entered are invoked, the (-ve) exception
value is then returned by catch_exceptions. If FUNC() returns
normally (with a positive or zero return value) then that value is
returned by catch_exceptions(). It is an internal_error() for
FUNC() to return a negative value.
For the period of the FUNC() call: UIOUT is installed as the output
builder; ERRSTRING is installed as the error/quit message; and a
new cleanup_chain is established. The old values are restored
before catch_exceptions() returns.
The variant catch_exceptions_with_msg() is the same as
catch_exceptions() but adds the ability to return an allocated
copy of the gdb error message. This is used when a silent error is
issued and the caller wants to manually issue the error message.
MASK specifies what to catch; it is normally set to RETURN_MASK_ALL
if the code which calls catch_exceptions is not set up to deal with
a quit which isn't caught. But if the code can deal with it, it
generally should be RETURN_MASK_ERROR, unless for some reason it is
more useful to abort only the portion of the operation inside the
catch_exceptions. Note that quit should return to the command line
fairly quickly, even if some further processing is being done.
FIXME; cagney/2001-08-13: The need to override the global UIOUT
builder variable should just go away. */
struct ui_out;
typedef int (catch_exceptions_ftype) (struct ui_out *ui_out, void *args);
extern int catch_exceptions (struct ui_out *uiout,
catch_exceptions_ftype *func, void *func_args,
return_mask mask);
typedef void (catch_exception_ftype) (struct ui_out *ui_out, void *args);
extern int catch_exceptions_with_msg (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
char **gdberrmsg,
return_mask mask);
/* Compare two exception objects for print equality. */
extern int exception_print_same (struct gdb_exception e1,
struct gdb_exception e2);

58
gdb/gdb.h
View File

@ -1,58 +0,0 @@
/* Library interface into GDB.
Copyright (C) 1999-2017 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef GDB_H
#define GDB_H
struct ui_out;
/* Return-code (RC) from a gdb library call. (The abreviation RC is
taken from the sim/common directory.) */
enum gdb_rc {
/* The operation failed. The failure message can be fetched by
calling ``char *error_last_message(void)''. The value is
determined by the catch_errors() interface. The MSG parameter is
set to a freshly allocated copy of the error message. */
/* NOTE: Since ``defs.h:catch_errors()'' does not return an error /
internal / quit indication it is not possible to return that
here. */
GDB_RC_FAIL = 0,
/* No error occured but nothing happened. Due to the catch_errors()
interface, this must be non-zero. */
GDB_RC_NONE = 1,
/* The operation was successful. Due to the catch_errors()
interface, this must be non-zero. */
GDB_RC_OK = 2
};
/* Print the specified breakpoint on GDB_STDOUT. (Eventually this
function will ``print'' the object on ``output''). */
enum gdb_rc gdb_breakpoint_query (struct ui_out *uiout, int bnum,
char **error_message);
/* Switch thread and print notification. */
enum gdb_rc gdb_thread_select (struct ui_out *uiout, char *tidstr,
char **error_message);
/* Print a list of known thread ids. */
enum gdb_rc gdb_list_thread_ids (struct ui_out *uiout,
char **error_message);
#endif

6
gdb/gdbthread.h
View File

@ -679,6 +679,12 @@ extern int show_thread_that_caused_stop (void);
extern void print_selected_thread_frame (struct ui_out *uiout,
user_selected_what selection);
/* Helper for the CLI's "thread" command and for MI's -thread-select.
Selects thread THR. TIDSTR is the original string the thread ID
was parsed from. This is used in the error message if THR is not
alive anymore. */
extern void thread_select (const char *tidstr, thread_info *thr);
extern struct thread_info *thread_list;
#endif /* GDBTHREAD_H */

13
gdb/mi/mi-cmd-break.c
View File

@ -24,7 +24,6 @@
#include "mi-out.h"
#include "breakpoint.h"
#include "mi-getopt.h"
#include "gdb.h"
#include "observer.h"
#include "mi-main.h"
#include "mi-cmd-break.h"
@ -53,7 +52,17 @@ static void
breakpoint_notify (struct breakpoint *b)
{
if (mi_can_breakpoint_notify)
gdb_breakpoint_query (current_uiout, b->number, NULL);
{
TRY
{
print_breakpoint (b);
}
CATCH (ex, RETURN_MASK_ALL)
{
exception_print (gdb_stderr, ex);
}
END_CATCH
}
}
enum bp_type

1
gdb/mi/mi-cmd-catch.c
View File

@ -21,7 +21,6 @@
#include "defs.h"
#include "arch-utils.h"
#include "breakpoint.h"
#include "gdb.h"
#include "ada-lang.h"
#include "mi-cmds.h"
#include "mi-getopt.h"

74
gdb/mi/mi-interp.c
View File

@ -33,7 +33,6 @@
#include "observer.h"
#include "gdbthread.h"
#include "solist.h"
#include "gdb.h"
#include "objfiles.h"
#include "tracepoint.h"
#include "cli-out.h"
@ -828,6 +827,38 @@ mi_tsv_modified (const struct trace_state_variable *tsv)
}
}
/* Print breakpoint BP on MI's event channel. */
static void
mi_print_breakpoint_for_event (struct mi_interp *mi, breakpoint *bp)
{
ui_out *mi_uiout = interp_ui_out (mi);
/* We want the output from print_breakpoint to go to
mi->event_channel. One approach would be to just call
print_breakpoint, and then use mi_out_put to send the current
content of mi_uiout into mi->event_channel. However, that will
break if anything is output to mi_uiout prior to calling the
breakpoint_created notifications. So, we use
ui_out_redirect. */
mi_uiout->redirect (mi->event_channel);
TRY
{
scoped_restore restore_uiout
= make_scoped_restore (&current_uiout, mi_uiout);
print_breakpoint (bp);
}
CATCH (ex, RETURN_MASK_ALL)
{
exception_print (gdb_stderr, ex);
}
END_CATCH
mi_uiout->redirect (NULL);
}
/* Emit notification about a created breakpoint. */
static void
@ -842,36 +873,16 @@ mi_breakpoint_created (struct breakpoint *b)
SWITCH_THRU_ALL_UIS ()
{
struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
struct ui_out *mi_uiout;
if (mi == NULL)
continue;
mi_uiout = interp_ui_out (top_level_interpreter ());
target_terminal::scoped_restore_terminal_state term_state;
target_terminal::ours_for_output ();
fprintf_unfiltered (mi->event_channel,
"breakpoint-created");
/* We want the output from gdb_breakpoint_query to go to
mi->event_channel. One approach would be to just call
gdb_breakpoint_query, and then use mi_out_put to send the current
content of mi_uiout into mi->event_channel. However, that will
break if anything is output to mi_uiout prior to calling the
breakpoint_created notifications. So, we use
ui_out_redirect. */
mi_uiout->redirect (mi->event_channel);
TRY
{
gdb_breakpoint_query (mi_uiout, b->number, NULL);
}
CATCH (e, RETURN_MASK_ERROR)
{
}
END_CATCH
mi_uiout->redirect (NULL);
mi_print_breakpoint_for_event (mi, b);
gdb_flush (mi->event_channel);
}
@ -927,24 +938,7 @@ mi_breakpoint_modified (struct breakpoint *b)
target_terminal::ours_for_output ();
fprintf_unfiltered (mi->event_channel,
"breakpoint-modified");
/* We want the output from gdb_breakpoint_query to go to
mi->event_channel. One approach would be to just call
gdb_breakpoint_query, and then use mi_out_put to send the current
content of mi_uiout into mi->event_channel. However, that will
break if anything is output to mi_uiout prior to calling the
breakpoint_created notifications. So, we use
ui_out_redirect. */
mi->mi_uiout->redirect (mi->event_channel);
TRY
{
gdb_breakpoint_query (mi->mi_uiout, b->number, NULL);
}
CATCH (e, RETURN_MASK_ERROR)
{
}
END_CATCH
mi->mi_uiout->redirect (NULL);
mi_print_breakpoint_for_event (mi, b);
gdb_flush (mi->event_channel);
}

49
gdb/mi/mi-main.c
View File

@ -38,7 +38,6 @@
#include "gdbcore.h" /* For write_memory(). */
#include "value.h"
#include "regcache.h"
#include "gdb.h"
#include "frame.h"
#include "mi-main.h"
#include "mi-common.h"
@ -555,21 +554,17 @@ mi_cmd_target_flash_erase (const char *command, char **argv, int argc)
void
mi_cmd_thread_select (const char *command, char **argv, int argc)
{
enum gdb_rc rc;
char *mi_error_message;
ptid_t previous_ptid = inferior_ptid;
if (argc != 1)
error (_("-thread-select: USAGE: threadnum."));
rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
int num = value_as_long (parse_and_eval (argv[0]));
thread_info *thr = find_thread_global_id (num);
if (thr == NULL)
error (_("Thread ID %d not known."), num);
/* If thread switch did not succeed don't notify or print. */
if (rc == GDB_RC_FAIL)
{
make_cleanup (xfree, mi_error_message);
error ("%s", mi_error_message);
}
ptid_t previous_ptid = inferior_ptid;
thread_select (argv[0], thr);
print_selected_thread_frame (current_uiout,
USER_SELECTED_THREAD | USER_SELECTED_FRAME);
@ -585,19 +580,31 @@ mi_cmd_thread_select (const char *command, char **argv, int argc)
void
mi_cmd_thread_list_ids (const char *command, char **argv, int argc)
{
enum gdb_rc rc;
char *mi_error_message;
if (argc != 0)
error (_("-thread-list-ids: No arguments required."));
rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
int num = 0;
int current_thread = -1;
if (rc == GDB_RC_FAIL)
{
make_cleanup (xfree, mi_error_message);
error ("%s", mi_error_message);
}
update_thread_list ();
{
ui_out_emit_tuple tuple_emitter (current_uiout, "thread-ids");
struct thread_info *tp;
ALL_NON_EXITED_THREADS (tp)
{
if (tp->ptid == inferior_ptid)
current_thread = tp->global_num;
num++;
current_uiout->field_int ("thread-id", tp->global_num);
}
}
if (current_thread != -1)
current_uiout->field_int ("current-thread-id", current_thread);
current_uiout->field_int ("number-of-threads", num);
}
void

35
gdb/remote-fileio.c
View File

@ -1118,10 +1118,9 @@ static struct {
{ NULL, NULL }
};
static int
do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
static void
do_remote_fileio_request (char *buf)
{
char *buf = (char *) buf_arg;
char *c;
int idx;
@ -1135,10 +1134,10 @@ do_remote_fileio_request (struct ui_out *uiout, void *buf_arg)
for (idx = 0; remote_fio_func_map[idx].name; ++idx)
if (!strcmp (remote_fio_func_map[idx].name, buf))
break;
if (!remote_fio_func_map[idx].name) /* ERROR: No such function. */
return RETURN_ERROR;
remote_fio_func_map[idx].func (c);
return 0;
if (!remote_fio_func_map[idx].name)
remote_fileio_reply (-1, FILEIO_ENOSYS);
else
remote_fio_func_map[idx].func (c);
}
/* Close any open descriptors, and reinitialize the file mapping. */
@ -1188,20 +1187,18 @@ remote_fileio_request (char *buf, int ctrlc_pending_p)
}
else
{
ex = catch_exceptions (current_uiout,
do_remote_fileio_request, (void *)buf,
RETURN_MASK_ALL);
switch (ex)
TRY
{
case RETURN_ERROR:
remote_fileio_reply (-1, FILEIO_ENOSYS);
break;
case RETURN_QUIT:
remote_fileio_reply (-1, FILEIO_EINTR);
break;
default:
break;
do_remote_fileio_request (buf);
}
CATCH (ex, RETURN_MASK_ALL)
{
if (ex.reason == RETURN_QUIT)
remote_fileio_reply (-1, FILEIO_EINTR);
else
remote_fileio_reply (-1, FILEIO_EIO);
}
END_CATCH
}
quit_handler = remote_fileio_o_quit_handler;

55
gdb/symfile-mem.c
View File

@ -167,31 +167,6 @@ add_symbol_file_from_memory_command (const char *args, int from_tty)
symbol_file_add_from_memory (templ, addr, 0, NULL, from_tty);
}
/* Arguments for symbol_file_add_from_memory_wrapper. */
struct symbol_file_add_from_memory_args
{
struct bfd *bfd;
CORE_ADDR sysinfo_ehdr;
size_t size;
char *name;
int from_tty;
};
/* Wrapper function for symbol_file_add_from_memory, for
catch_exceptions. */
static int
symbol_file_add_from_memory_wrapper (struct ui_out *uiout, void *data)
{
struct symbol_file_add_from_memory_args *args
= (struct symbol_file_add_from_memory_args *) data;
symbol_file_add_from_memory (args->bfd, args->sysinfo_ehdr, args->size,
args->name, args->from_tty);
return 0;
}
/* Try to add the symbols for the vsyscall page, if there is one.
This function is called via the inferior_created observer. */
@ -203,7 +178,6 @@ add_vsyscall_page (struct target_ops *target, int from_tty)
if (gdbarch_vsyscall_range (target_gdbarch (), &vsyscall_range))
{
struct bfd *bfd;
struct symbol_file_add_from_memory_args args;
if (core_bfd != NULL)
bfd = core_bfd;
@ -221,18 +195,25 @@ add_vsyscall_page (struct target_ops *target, int from_tty)
"because no executable was specified"));
return;
}
args.bfd = bfd;
args.sysinfo_ehdr = vsyscall_range.start;
args.size = vsyscall_range.length;
args.name = xstrprintf ("system-supplied DSO at %s",
paddress (target_gdbarch (), vsyscall_range.start));
/* Pass zero for FROM_TTY, because the action of loading the
vsyscall DSO was not triggered by the user, even if the user
typed "run" at the TTY. */
args.from_tty = 0;
catch_exceptions (current_uiout, symbol_file_add_from_memory_wrapper,
&args, RETURN_MASK_ALL);
char *name = xstrprintf ("system-supplied DSO at %s",
paddress (target_gdbarch (), vsyscall_range.start));
TRY
{
/* Pass zero for FROM_TTY, because the action of loading the
vsyscall DSO was not triggered by the user, even if the
user typed "run" at the TTY. */
symbol_file_add_from_memory (bfd,
vsyscall_range.start,
vsyscall_range.length,
name,
0 /* from_tty */);
}
CATCH (ex, RETURN_MASK_ALL)
{
exception_print (gdb_stderr, ex);
}
END_CATCH
}
}

5
gdb/testsuite/ChangeLog
View File

@ -1,3 +1,8 @@
2017-10-10 Pedro Alves <palves@redhat.com>
* gdb.mi/mi-pthreads.exp (check_mi_thread_command_set): Don't
expect CLI output.
2017-10-10 Pedro Alves <palves@redhat.com>
* lib/selftest-support.exp (selftest_setup): Update for

2
gdb/testsuite/gdb.mi/mi-pthreads.exp
View File

@ -39,7 +39,7 @@ proc check_mi_thread_command_set {} {
"check_mi_thread_command_set: -thread-select"
mi_gdb_test "-thread-select 123456789" \
{&.*\^error,msg="Thread ID 123456789 not known\."} \
{\^error,msg="Thread ID 123456789 not known\."} \
"check_mi_thread_command_set: -thread-select 123456789"
foreach thread $thread_list {

86
gdb/thread.c
View File

@ -30,7 +30,6 @@
#include "command.h"
#include "gdbcmd.h"
#include "regcache.h"
#include "gdb.h"
#include "btrace.h"
#include <ctype.h>
@ -720,50 +719,6 @@ any_live_thread_of_process (int pid)
return tp_executing;
}
/* Print a list of thread ids currently known, and the total number of
threads. To be used from within catch_errors. */
static int
do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
{
struct thread_info *tp;
int num = 0;
int current_thread = -1;
update_thread_list ();
{
ui_out_emit_tuple tuple_emitter (uiout, "thread-ids");
for (tp = thread_list; tp; tp = tp->next)
{
if (tp->state == THREAD_EXITED)
continue;
if (tp->ptid == inferior_ptid)
current_thread = tp->global_num;
num++;
uiout->field_int ("thread-id", tp->global_num);
}
}
if (current_thread != -1)
uiout->field_int ("current-thread-id", current_thread);
uiout->field_int ("number-of-threads", num);
return GDB_RC_OK;
}
/* Official gdblib interface function to get a list of thread ids and
the total number. */
enum gdb_rc
gdb_list_thread_ids (struct ui_out *uiout, char **error_message)
{
if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL,
error_message, RETURN_MASK_ALL) < 0)
return GDB_RC_FAIL;
return GDB_RC_OK;
}
/* Return true if TP is an active thread. */
static int
thread_alive (struct thread_info *tp)
@ -1885,13 +1840,8 @@ thread_command (char *tidstr, int from_tty)
else
{
ptid_t previous_ptid = inferior_ptid;
enum gdb_rc result;
result = gdb_thread_select (current_uiout, tidstr, NULL);
/* If thread switch did not succeed don't notify or print. */
if (result == GDB_RC_FAIL)
return;
thread_select (tidstr, parse_thread_id (tidstr, NULL));
/* Print if the thread has not changed, otherwise an event will
be sent. */
@ -1991,26 +1941,11 @@ show_print_thread_events (struct ui_file *file, int from_tty,
value);
}
static int
do_captured_thread_select (struct ui_out *uiout, void *tidstr_v)
/* See gdbthread.h. */
void
thread_select (const char *tidstr, thread_info *tp)
{
const char *tidstr = (const char *) tidstr_v;
struct thread_info *tp;
if (uiout->is_mi_like_p ())
{
int num = value_as_long (parse_and_eval (tidstr));
tp = find_thread_global_id (num);
if (tp == NULL)
error (_("Thread ID %d not known."), num);
}
else
{
tp = parse_thread_id (tidstr, NULL);
gdb_assert (tp != NULL);
}
if (!thread_alive (tp))
error (_("Thread ID %s has terminated."), tidstr);
@ -2021,8 +1956,6 @@ do_captured_thread_select (struct ui_out *uiout, void *tidstr_v)
/* Since the current thread may have changed, see if there is any
exited thread we can now delete. */
prune_threads ();
return GDB_RC_OK;
}
/* Print thread and frame switch command response. */
@ -2067,15 +2000,6 @@ print_selected_thread_frame (struct ui_out *uiout,
}
}
enum gdb_rc
gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message)
{
if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr,
error_message, RETURN_MASK_ALL) < 0)
return GDB_RC_FAIL;
return GDB_RC_OK;
}
/* Update the 'threads_executing' global based on the threads we know
about right now. */