int
gdb_main (struct captured_main_args *args)
{
use_windows = args->use_windows;
catch_errors (captured_main, args, "", RETURN_MASK_ALL);
return 0;
}
/* Called by the event loop to process a SIGHUP */
static void
async_disconnect (gdb_client_data arg)
{
catch_errors (quit_cover, NULL,
"Could not kill the program being debugged",
RETURN_MASK_ALL);
signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
kill (getpid (), SIGHUP);
}
int
gdb_main (struct captured_main_args *args)
{
use_windows = args->use_windows;
catch_errors (captured_main, args, "", RETURN_MASK_ALL);
/* The only way to end up here is by an error (normal exit is
handled by quit_force()), hence always return an error status. */
return 1;
}
int
gdb_value_fetch_lazy (value_ptr value)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = value;
return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
"", RETURN_MASK_ERROR);
}
/* General function to handle events in the inferior. So far it just
takes care of detecting errors reported by select() or poll(),
otherwise it assumes that all is OK, and goes on reading data from
the fd. This however may not always be what we want to do. */
void
inferior_event_handler (enum inferior_event_type event_type,
gdb_client_data client_data)
{
switch (event_type)
{
case INF_ERROR:
printf_unfiltered ("error detected from target.\n");
target_async (NULL, 0);
pop_target ();
discard_all_continuations ();
do_exec_error_cleanups (ALL_CLEANUPS);
break;
case INF_REG_EVENT:
/* Use catch errors for now, until the inner layers of
fetch_inferior_event (i.e. readchar) can return meaningful
error status. If an error occurs while getting an event from
the target, just get rid of the target. */
if (!catch_errors (fetch_inferior_event_wrapper,
client_data, "", RETURN_MASK_ALL))
{
target_async (NULL, 0);
pop_target ();
discard_all_continuations ();
do_exec_error_cleanups (ALL_CLEANUPS);
display_gdb_prompt (0);
}
break;
case INF_EXEC_COMPLETE:
/* Is there anything left to do for the command issued to
complete? */
do_all_continuations ();
/* Reset things after target has stopped for the async commands. */
complete_execution ();
break;
case INF_EXEC_CONTINUE:
/* Is there anything left to do for the command issued to
complete? */
do_all_intermediate_continuations ();
break;
case INF_QUIT_REQ:
/* FIXME: ezannoni 1999-10-04. This call should really be a
target vector entry, so that it can be used for any kind of
targets. */
async_remote_interrupt_twice (NULL);
break;
case INF_TIMER:
default:
printf_unfiltered ("Event type not recognized.\n");
break;
}
}
void
start_event_loop (void)
{
/* Loop until there is nothing to do. This is the entry point to the
event loop engine. gdb_do_one_event, called via catch_errors()
will process one event for each invocation. It blocks waits for
an event and then processes it. >0 when an event is processed, 0
when catch_errors() caught an error and <0 when there are no
longer any event sources registered. */
while (1)
{
int gdb_result, interp_result;
gdb_result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
if (gdb_result < 0)
break;
#if 0
interp_result = catch_errors (interpreter_do_one_event, 0, "", RETURN_MASK_ALL);
if (interp_result < 0)
{
/* FIXME - kill the interpreter */
}
#endif
printf ("FAIL\n");
/* If we long-jumped out of the do_one_event, we probably
didn't get around to resetting the prompt, which leaves
readline in a messed-up state. Reset it here. */
if (gdb_result == 0)
{
display_gdb_prompt (0);
/* Maybe better to set a flag to be checked somewhere as to
whether display the prompt or not. */
}
}
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
return;
}
static gdb_result
call_wrapped_function (catch_errors_ftype *fn, struct gdb_wrapper_arguments *arg)
{
if (!catch_errors (fn, (char *) &arg, "", RETURN_MASK_ERROR))
{
/* An error occurred */
return GDB_ERROR;
}
return GDB_OK;
}
int
vmap_add_symbols (struct vmap *vp)
{
if (catch_errors (objfile_symbol_add, vp->objfile,
"Error while reading shared library symbols:\n",
RETURN_MASK_ALL))
{
/* Note this is only done if symbol reading was successful. */
vp->loaded = 1;
vmap_symtab (vp);
return 1;
}
return 0;
}
void
start_event_loop (void)
{
/* Loop until there is nothing to do. This is the entry point to the
event loop engine. gdb_do_one_event, called via catch_errors()
will process one event for each invocation. It blocks waits for
an event and then processes it. >0 when an event is processed, 0
when catch_errors() caught an error and <0 when there are no
longer any event sources registered. */
while (1)
{
int gdb_result;
gdb_result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
if (gdb_result < 0)
break;
/* If we long-jumped out of do_one_event, we probably
didn't get around to resetting the prompt, which leaves
readline in a messed-up state. Reset it here. */
if (gdb_result == 0)
{
/* If any exception escaped to here, we better enable
stdin. Otherwise, any command that calls async_disable_stdin,
and then throws, will leave stdin inoperable. */
async_enable_stdin ();
/* FIXME: this should really be a call to a hook that is
interface specific, because interfaces can display the
prompt in their own way. */
display_gdb_prompt (0);
/* This call looks bizarre, but it is required. If the user
entered a command that caused an error,
after_char_processing_hook won't be called from
rl_callback_read_char_wrapper. Using a cleanup there
won't work, since we want this function to be called
after a new prompt is printed. */
if (after_char_processing_hook)
(*after_char_processing_hook) ();
/* Maybe better to set a flag to be checked somewhere as to
whether display the prompt or not. */
}
}
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
return;
}
int
safe_read_memory_integer(CORE_ADDR memaddr, int len, LONGEST *return_value)
{
int status;
struct captured_read_memory_integer_arguments args;
args.memaddr = memaddr;
args.len = len;
args.signedp = 1;
status = catch_errors(do_captured_read_memory_integer, &args,
"", RETURN_MASK_ALL);
if (status)
*return_value = args.result.sresult;
return status;
}
int
gdb_evaluate_expression (struct expression *exp, value_ptr *value)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = exp;
if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
"", RETURN_MASK_ERROR))
{
/* An error occurred */
return 0;
}
*value = (value_ptr) args.result.pointer;
return 1;
}
int
gdb_value_ind (value_ptr val, value_ptr *rval)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = val;
if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
"", RETURN_MASK_ERROR))
{
/* An error occurred */
return 0;
}
*rval = (value_ptr) args.result.pointer;
return 1;
}
int
gdb_parse_and_eval_type (char *p, int length, struct type **type)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = p;
args.args[1].integer = length;
if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args,
"", RETURN_MASK_ALL))
{
/* An error occurred */
return 0;
}
*type = (struct type *) args.result.pointer;
return 1;
}
int
ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
CORE_ADDR address, struct ui_file *stream, int format,
int deref_ref, int recurse, enum val_prettyprint pretty)
{
struct ada_val_print_args args;
args.type = type;
args.valaddr0 = valaddr0;
args.embedded_offset = embedded_offset;
args.address = address;
args.stream = stream;
args.format = format;
args.deref_ref = deref_ref;
args.recurse = recurse;
args.pretty = pretty;
return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
}
int
gdb_value_assign (value_ptr val1, value_ptr val2, value_ptr *result)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = val1;
args.args[1].pointer = val2;
if (!catch_errors ((catch_errors_ftype *) wrap_value_assign, &args,
"", RETURN_MASK_ERROR))
{
/* An error occurred */
return 0;
}
*result = (value_ptr) args.result.pointer;
return 1;
}
void
start_event_loop (void)
{
/* Loop until there is nothing to do. This is the entry point to the
event loop engine. gdb_do_one_event, called via catch_errors()
will process one event for each invocation. It blocks waits for
an event and then processes it. >0 when an event is processed, 0
when catch_errors() caught an error and <0 when there are no
longer any event sources registered. */
while (1)
{
int gdb_result;
uiout = interp_ui_out (current_interp ());
gdb_result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
if (gdb_result < 0)
break;
/* If we long-jumped out of do_one_event, we probably
didn't get around to resetting the prompt, which leaves
readline in a messed-up state. Reset it here. */
if (gdb_result == 0)
{
/* APPLE LOCAL whack-a-FIXME */
display_gdb_prompt (0);
/* This call looks bizarre, but it is required. If the user
entered a command that caused an error,
after_char_processing_hook won't be called from
rl_callback_read_char_wrapper. Using a cleanup there
won't work, since we want this function to be called
after a new prompt is printed. */
if (after_char_processing_hook)
(*after_char_processing_hook) ();
/* Maybe better to set a flag to be checked somewhere as to
whether display the prompt or not. */
}
}
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
return;
}
int
gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
struct expression **expression)
{
struct gdb_wrapper_arguments args;
args.args[0].pointer = stringptr;
args.args[1].pointer = block;
args.args[2].integer = comma;
if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
"", RETURN_MASK_ERROR))
{
/* An error occurred */
return 0;
}
*expression = (struct expression *) args.result.pointer;
return 1;
}
static int
captured_main (void *data)
{
struct captured_main_args *context = data;
int argc = context->argc;
char **argv = context->argv;
int count;
static int quiet = 0;
static int batch = 0;
static int set_args = 0;
/* Pointers to various arguments from command line. */
char *symarg = NULL;
char *execarg = NULL;
char *corearg = NULL;
char *cdarg = NULL;
char *ttyarg = NULL;
/* These are static so that we can take their address in an initializer. */
static int print_help;
static int print_version;
/* Pointers to all arguments of --command option. */
char **cmdarg;
/* Allocated size of cmdarg. */
int cmdsize;
/* Number of elements of cmdarg used. */
int ncmd;
/* Indices of all arguments of --directory option. */
char **dirarg;
/* Allocated size. */
int dirsize;
/* Number of elements used. */
int ndir;
struct stat homebuf, cwdbuf;
char *homedir, *homeinit;
int i;
long time_at_startup = get_run_time ();
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* This needs to happen before the first use of malloc. */
init_malloc (NULL);
#ifdef HAVE_SBRK
lim_at_start = (char *) sbrk (0);
#endif
#if defined (ALIGN_STACK_ON_STARTUP)
i = (int) &count & 0x3;
if (i != 0)
alloca (4 - i);
#endif
cmdsize = 1;
cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
ncmd = 0;
dirsize = 1;
dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
ndir = 0;
quit_flag = 0;
line = (char *) xmalloc (linesize);
line[0] = '\0'; /* Terminate saved (now empty) cmd line */
instream = stdin;
getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
current_directory = gdb_dirbuf;
gdb_stdout = stdio_fileopen (stdout);
gdb_stderr = stdio_fileopen (stderr);
gdb_stdlog = gdb_stderr; /* for moment */
gdb_stdtarg = gdb_stderr; /* for moment */
gdb_stdin = stdio_fileopen (stdin);
gdb_stdtargerr = gdb_stderr; /* for moment */
gdb_stdtargin = gdb_stdin; /* for moment */
/* initialize error() */
error_init ();
/* Set the sysroot path. */
#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
if (gdb_sysroot)
{
struct stat s;
int res = 0;
if (stat (gdb_sysroot, &s) == 0)
if (S_ISDIR (s.st_mode))
res = 1;
if (res == 0)
{
xfree (gdb_sysroot);
gdb_sysroot = TARGET_SYSTEM_ROOT;
}
}
else
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
#if defined (TARGET_SYSTEM_ROOT)
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
gdb_sysroot = "";
#endif
#endif
/* There will always be an interpreter. Either the one passed into
this captured main, or one specified by the user at start up, or
the console. Initialize the interpreter to the one requested by
the application. */
interpreter_p = xstrdup (context->interpreter_p);
/* Parse arguments and options. */
{
int c;
/* When var field is 0, use flag field to record the equivalent
short option (or arbitrary numbers starting at 10 for those
with no equivalent). */
enum {
OPT_SE = 10,
OPT_CD,
OPT_ANNOTATE,
OPT_STATISTICS,
OPT_TUI,
OPT_NOWINDOWS,
OPT_WINDOWS
};
static struct option long_options[] =
{
#if defined(TUI)
{"tui", no_argument, 0, OPT_TUI},
#endif
{"xdb", no_argument, &xdb_commands, 1},
{"dbx", no_argument, &dbx_commands, 1},
{"readnow", no_argument, &readnow_symbol_files, 1},
{"r", no_argument, &readnow_symbol_files, 1},
{"quiet", no_argument, &quiet, 1},
{"q", no_argument, &quiet, 1},
{"silent", no_argument, &quiet, 1},
{"nx", no_argument, &inhibit_gdbinit, 1},
{"n", no_argument, &inhibit_gdbinit, 1},
{"batch", no_argument, &batch, 1},
{"epoch", no_argument, &epoch_interface, 1},
/* This is a synonym for "--annotate=1". --annotate is now preferred,
but keep this here for a long time because people will be running
emacses which use --fullname. */
{"fullname", no_argument, 0, 'f'},
{"f", no_argument, 0, 'f'},
{"annotate", required_argument, 0, OPT_ANNOTATE},
{"help", no_argument, &print_help, 1},
{"se", required_argument, 0, OPT_SE},
{"symbols", required_argument, 0, 's'},
{"s", required_argument, 0, 's'},
{"exec", required_argument, 0, 'e'},
{"e", required_argument, 0, 'e'},
{"core", required_argument, 0, 'c'},
{"c", required_argument, 0, 'c'},
{"pid", required_argument, 0, 'p'},
{"p", required_argument, 0, 'p'},
{"command", required_argument, 0, 'x'},
{"version", no_argument, &print_version, 1},
{"x", required_argument, 0, 'x'},
#ifdef GDBTK
{"tclcommand", required_argument, 0, 'z'},
{"enable-external-editor", no_argument, 0, 'y'},
{"editor-command", required_argument, 0, 'w'},
#endif
{"ui", required_argument, 0, 'i'},
{"interpreter", required_argument, 0, 'i'},
{"i", required_argument, 0, 'i'},
{"directory", required_argument, 0, 'd'},
{"d", required_argument, 0, 'd'},
{"cd", required_argument, 0, OPT_CD},
{"tty", required_argument, 0, 't'},
{"baud", required_argument, 0, 'b'},
{"b", required_argument, 0, 'b'},
{"nw", no_argument, NULL, OPT_NOWINDOWS},
{"nowindows", no_argument, NULL, OPT_NOWINDOWS},
{"w", no_argument, NULL, OPT_WINDOWS},
{"windows", no_argument, NULL, OPT_WINDOWS},
{"statistics", no_argument, 0, OPT_STATISTICS},
{"write", no_argument, &write_files, 1},
{"args", no_argument, &set_args, 1},
{0, no_argument, 0, 0}
};
while (1)
{
int option_index;
c = getopt_long_only (argc, argv, "",
long_options, &option_index);
if (c == EOF || set_args)
break;
/* Long option that takes an argument. */
if (c == 0 && long_options[option_index].flag == 0)
c = long_options[option_index].val;
switch (c)
{
case 0:
/* Long option that just sets a flag. */
break;
case OPT_SE:
symarg = optarg;
execarg = optarg;
break;
case OPT_CD:
cdarg = optarg;
break;
case OPT_ANNOTATE:
/* FIXME: what if the syntax is wrong (e.g. not digits)? */
annotation_level = atoi (optarg);
break;
case OPT_STATISTICS:
/* Enable the display of both time and space usage. */
display_time = 1;
display_space = 1;
break;
case OPT_TUI:
/* --tui is equivalent to -i=tui. */
xfree (interpreter_p);
interpreter_p = xstrdup ("tui");
break;
case OPT_WINDOWS:
/* FIXME: cagney/2003-03-01: Not sure if this option is
actually useful, and if it is, what it should do. */
use_windows = 1;
break;
case OPT_NOWINDOWS:
/* -nw is equivalent to -i=console. */
xfree (interpreter_p);
interpreter_p = xstrdup (INTERP_CONSOLE);
use_windows = 0;
break;
case 'f':
annotation_level = 1;
/* We have probably been invoked from emacs. Disable window interface. */
use_windows = 0;
break;
case 's':
symarg = optarg;
break;
case 'e':
execarg = optarg;
break;
case 'c':
corearg = optarg;
break;
case 'p':
/* "corearg" is shared by "--core" and "--pid" */
corearg = optarg;
break;
case 'x':
cmdarg[ncmd++] = optarg;
if (ncmd >= cmdsize)
{
cmdsize *= 2;
cmdarg = (char **) xrealloc ((char *) cmdarg,
cmdsize * sizeof (*cmdarg));
}
break;
#ifdef GDBTK
case 'z':
{
extern int gdbtk_test (char *);
if (!gdbtk_test (optarg))
{
fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
argv[0], optarg);
exit (1);
}
break;
}
case 'y':
/* Backwards compatibility only. */
break;
case 'w':
{
external_editor_command = xstrdup (optarg);
break;
}
#endif /* GDBTK */
case 'i':
xfree (interpreter_p);
interpreter_p = xstrdup (optarg);
break;
case 'd':
dirarg[ndir++] = optarg;
if (ndir >= dirsize)
{
dirsize *= 2;
dirarg = (char **) xrealloc ((char *) dirarg,
dirsize * sizeof (*dirarg));
}
break;
case 't':
ttyarg = optarg;
break;
case 'q':
quiet = 1;
break;
case 'b':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set baud rate to `%s'.\n"), optarg);
else
baud_rate = i;
}
break;
case 'l':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set timeout limit to `%s'.\n"), optarg);
else
remote_timeout = i;
}
break;
case '?':
fprintf_unfiltered (gdb_stderr,
_("Use `%s --help' for a complete list of options.\n"),
argv[0]);
exit (1);
}
}
/* If --help or --version, disable window interface. */
if (print_help || print_version)
{
use_windows = 0;
}
if (set_args)
{
/* The remaining options are the command-line options for the
inferior. The first one is the sym/exec file, and the rest
are arguments. */
if (optind >= argc)
{
fprintf_unfiltered (gdb_stderr,
_("%s: `--args' specified but no program specified\n"),
argv[0]);
exit (1);
}
symarg = argv[optind];
execarg = argv[optind];
++optind;
set_inferior_args_vector (argc - optind, &argv[optind]);
}
else
{
/* OK, that's all the options. The other arguments are filenames. */
count = 0;
for (; optind < argc; optind++)
switch (++count)
{
case 1:
symarg = argv[optind];
execarg = argv[optind];
break;
case 2:
/* The documentation says this can be a "ProcID" as well.
We will try it as both a corefile and a pid. */
corearg = argv[optind];
break;
case 3:
fprintf_unfiltered (gdb_stderr,
_("Excess command line arguments ignored. (%s%s)\n"),
argv[optind], (optind == argc - 1) ? "" : " ...");
break;
}
}
if (batch)
quiet = 1;
}
/* Initialize all files. Give the interpreter a chance to take
control of the console via the deprecated_init_ui_hook(). */
gdb_init (argv[0]);
/* Do these (and anything which might call wrap_here or *_filtered)
after initialize_all_files() but before the interpreter has been
installed. Otherwize the help/version messages will be eaten by
the interpreter's output handler. */
if (print_version)
{
print_gdb_version (gdb_stdout);
wrap_here ("");
printf_filtered ("\n");
exit (0);
}
if (print_help)
{
print_gdb_help (gdb_stdout);
fputs_unfiltered ("\n", gdb_stdout);
exit (0);
}
/* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message before the interpreter is installed. That way
it isn't encapsulated in MI output. */
if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
{
/* Print all the junk at the top, with trailing "..." if we are about
to read a symbol file (possibly slowly). */
print_gdb_version (gdb_stdout);
if (symarg)
printf_filtered ("..");
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
/* Install the default UI. All the interpreters should have had a
look at things by now. Initialize the default interpreter. */
{
/* Find it. */
struct interp *interp = interp_lookup (interpreter_p);
if (interp == NULL)
error ("Interpreter `%s' unrecognized", interpreter_p);
/* Install it. */
if (!interp_set (interp))
{
fprintf_unfiltered (gdb_stderr,
"Interpreter `%s' failed to initialize.\n",
interpreter_p);
exit (1);
}
}
/* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message after the interpreter is installed when it is
any sane interpreter. */
if (!quiet && !current_interp_named_p (INTERP_MI1))
{
/* Print all the junk at the top, with trailing "..." if we are about
to read a symbol file (possibly slowly). */
print_gdb_version (gdb_stdout);
if (symarg)
printf_filtered ("..");
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
error_pre_print = "\n\n";
quit_pre_print = error_pre_print;
/* We may get more than one warning, don't double space all of them... */
warning_pre_print = _("\nwarning: ");
/* Read and execute $HOME/.gdbinit file, if it exists. This is done
*before* all the command line arguments are processed; it sets
global parameters, which are independent of what file you are
debugging or what directory you are in. */
homedir = getenv ("HOME");
if (homedir)
{
homeinit = (char *) alloca (strlen (homedir) +
strlen (gdbinit) + 10);
strcpy (homeinit, homedir);
strcat (homeinit, "/");
strcat (homeinit, gdbinit);
if (!inhibit_gdbinit)
{
catch_command_errors (source_command, homeinit, 0, RETURN_MASK_ALL);
}
/* Do stats; no need to do them elsewhere since we'll only
need them if homedir is set. Make sure that they are
zero in case one of them fails (this guarantees that they
won't match if either exists). */
memset (&homebuf, 0, sizeof (struct stat));
memset (&cwdbuf, 0, sizeof (struct stat));
stat (homeinit, &homebuf);
stat (gdbinit, &cwdbuf); /* We'll only need this if
homedir was set. */
}
/* Now perform all the actions indicated by the arguments. */
if (cdarg != NULL)
{
catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
}
for (i = 0; i < ndir; i++)
catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
xfree (dirarg);
if (execarg != NULL
&& symarg != NULL
&& strcmp (execarg, symarg) == 0)
{
/* The exec file and the symbol-file are the same. If we can't
open it, better only print one error message.
catch_command_errors returns non-zero on success! */
if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
else
{
if (execarg != NULL)
catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
if (symarg != NULL)
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
/* After the symbol file has been read, print a newline to get us
beyond the copyright line... But errors should still set off
the error message with a (single) blank line. */
if (!quiet)
printf_filtered ("\n");
error_pre_print = "\n";
quit_pre_print = error_pre_print;
warning_pre_print = _("\nwarning: ");
if (corearg != NULL)
{
/* corearg may be either a corefile or a pid.
If its first character is a digit, try attach first
and then corefile. Otherwise try corefile first. */
if (isdigit (corearg[0]))
{
if (catch_command_errors (attach_command, corearg,
!batch, RETURN_MASK_ALL) == 0)
catch_command_errors (core_file_command, corearg,
!batch, RETURN_MASK_ALL);
}
else /* Can't be a pid, better be a corefile. */
catch_command_errors (core_file_command, corearg,
!batch, RETURN_MASK_ALL);
}
if (ttyarg != NULL)
catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
/* Error messages should no longer be distinguished with extra output. */
error_pre_print = NULL;
quit_pre_print = NULL;
warning_pre_print = _("warning: ");
/* Read the .gdbinit file in the current directory, *if* it isn't
the same as the $HOME/.gdbinit file (it should exist, also). */
if (!homedir
|| memcmp ((char *) &homebuf, (char *) &cwdbuf, sizeof (struct stat)))
if (!inhibit_gdbinit)
{
catch_command_errors (source_command, gdbinit, 0, RETURN_MASK_ALL);
}
for (i = 0; i < ncmd; i++)
{
#if 0
/* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
expanded into a call to setjmp(). */
if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
{
/* NOTE: I am commenting this out, because it is not clear
where this feature is used. It is very old and
undocumented. ezannoni: 1999-05-04 */
#if 0
if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
read_command_file (stdin);
else
#endif
source_command (cmdarg[i], !batch);
do_cleanups (ALL_CLEANUPS);
}
#endif
catch_command_errors (source_command, cmdarg[i], !batch, RETURN_MASK_ALL);
}
xfree (cmdarg);
/* Read in the old history after all the command files have been read. */
init_history ();
if (batch)
{
if (attach_flag)
/* Either there was a problem executing the command in the
batch file aborted early, or the batch file forgot to do an
explicit detach. Explicitly detach the inferior ensuring
that there are no zombies. */
target_detach (NULL, 0);
/* We have hit the end of the batch file. */
exit (0);
}
/* Do any host- or target-specific hacks. This is used for i960 targets
to force the user to set a nindy target and spec its parameters. */
#ifdef BEFORE_MAIN_LOOP_HOOK
BEFORE_MAIN_LOOP_HOOK;
#endif
/* Show time and/or space usage. */
if (display_time)
{
long init_time = get_run_time () - time_at_startup;
printf_unfiltered (_("Startup time: %ld.%06ld\n"),
init_time / 1000000, init_time % 1000000);
}
if (display_space)
{
#ifdef HAVE_SBRK
extern char **environ;
char *lim = (char *) sbrk (0);
printf_unfiltered (_("Startup size: data size %ld\n"),
(long) (lim - (char *) &environ));
#endif
}
#if 0
/* FIXME: cagney/1999-11-06: The original main loop was like: */
while (1)
{
if (!SET_TOP_LEVEL ())
{
do_cleanups (ALL_CLEANUPS); /* Do complete cleanup */
/* GUIs generally have their own command loop, mainloop, or whatever.
This is a good place to gain control because many error
conditions will end up here via longjmp(). */
if (deprecated_command_loop_hook)
deprecated_command_loop_hook ();
else
deprecated_command_loop ();
quit_command ((char *) 0, instream == stdin);
}
}
/* NOTE: If the command_loop() returned normally, the loop would
attempt to exit by calling the function quit_command(). That
function would either call exit() or throw an error returning
control to SET_TOP_LEVEL. */
/* NOTE: The function do_cleanups() was called once each time round
the loop. The usefulness of the call isn't clear. If an error
was thrown, everything would have already been cleaned up. If
command_loop() returned normally and quit_command() was called,
either exit() or error() (again cleaning up) would be called. */
#endif
/* NOTE: cagney/1999-11-07: There is probably no reason for not
moving this loop and the code found in captured_command_loop()
into the command_loop() proper. The main thing holding back that
change - SET_TOP_LEVEL() - has been eliminated. */
while (1)
{
catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
}
/* No exit -- exit is through quit_command. */
}
static int
captured_main (void *data)
{
/* If you add initializations here, you also need to add then to the
proc do_steps_and_nexts in selftest.exp. */
struct captured_main_args *context = data;
int argc = context->argc;
char **argv = context->argv;
int count;
static int quiet = 0;
static int batch = 0;
static int set_args = 0;
/* Pointers to various arguments from command line. */
char *symarg = NULL;
char *execarg = NULL;
char *corearg = NULL;
char *cdarg = NULL;
char *ttyarg = NULL;
/* APPLE LOCAL: Set the osabi via option. */
char *osabiarg = NULL;
/* These are static so that we can take their address in an initializer. */
static int print_help;
static int print_version;
/* Pointers to all arguments of --command option. */
char **cmdarg;
/* Allocated size of cmdarg. */
int cmdsize;
/* Number of elements of cmdarg used. */
int ncmd;
/* Indices of all arguments of --directory option. */
char **dirarg;
/* Allocated size. */
int dirsize;
/* Number of elements used. */
int ndir;
/* APPLE LOCAL globalbuf */
struct stat homebuf, cwdbuf, globalbuf;
char *homedir;
/* APPLE LOCAL attach -waitfor */
char *attach_waitfor = NULL;
/* APPLE LOCAL: set the architecture. */
char *initial_arch = NULL;
int i;
long time_at_startup = get_run_time ();
#if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
setlocale (LC_MESSAGES, "");
#endif
#if defined (HAVE_SETLOCALE)
setlocale (LC_CTYPE, "");
#endif
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
/* APPLE LOCAL memory */
#ifdef USE_MMALLOC
init_mmalloc_default_pool ((PTR) NULL);
#endif
/* This needs to happen before the first use of malloc. */
init_malloc (NULL);
#ifdef HAVE_SBRK
lim_at_start = (char *) sbrk (0);
#endif
#if defined (ALIGN_STACK_ON_STARTUP)
i = (int) &count & 0x3;
if (i != 0)
alloca (4 - i);
#endif
cmdsize = 1;
cmdarg = (char **) xmalloc (cmdsize * sizeof (*cmdarg));
ncmd = 0;
dirsize = 1;
dirarg = (char **) xmalloc (dirsize * sizeof (*dirarg));
ndir = 0;
quit_flag = 0;
line = (char *) xmalloc (linesize);
line[0] = '\0'; /* Terminate saved (now empty) cmd line */
instream = stdin;
getcwd (gdb_dirbuf, sizeof (gdb_dirbuf));
current_directory = gdb_dirbuf;
/* APPLE LOCAL gdb_null */
gdb_null = ui_file_new ();
gdb_stdout = stdio_fileopen (stdout);
gdb_stderr = stdio_fileopen (stderr);
gdb_stdlog = gdb_stderr; /* for moment */
gdb_stdtarg = gdb_stderr; /* for moment */
gdb_stdin = stdio_fileopen (stdin);
gdb_stdtargerr = gdb_stderr; /* for moment */
gdb_stdtargin = gdb_stdin; /* for moment */
/* APPLE LOCAL: set our main thread's name */
#ifdef HAVE_PTHREAD_SETNAME_NP
pthread_setname_np ("gdb main thread");
#endif
/* Set the sysroot path. */
#ifdef TARGET_SYSTEM_ROOT_RELOCATABLE
gdb_sysroot = make_relative_prefix (argv[0], BINDIR, TARGET_SYSTEM_ROOT);
if (gdb_sysroot)
{
struct stat s;
int res = 0;
if (stat (gdb_sysroot, &s) == 0)
if (S_ISDIR (s.st_mode))
res = 1;
if (res == 0)
{
xfree (gdb_sysroot);
gdb_sysroot = TARGET_SYSTEM_ROOT;
}
}
else
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
#if defined (TARGET_SYSTEM_ROOT)
gdb_sysroot = TARGET_SYSTEM_ROOT;
#else
gdb_sysroot = "";
#endif
#endif
/* There will always be an interpreter. Either the one passed into
this captured main, or one specified by the user at start up, or
the console. Initialize the interpreter to the one requested by
the application. */
interpreter_p = xstrdup (context->interpreter_p);
/* Parse arguments and options. */
{
int c;
/* When var field is 0, use flag field to record the equivalent
short option (or arbitrary numbers starting at 10 for those
with no equivalent). */
enum {
OPT_SE = 10,
OPT_CD,
OPT_ANNOTATE,
OPT_STATISTICS,
OPT_TUI,
OPT_NOWINDOWS,
OPT_WINDOWS,
OPT_WAITFOR, /* APPLE LOCAL */
OPT_ARCH, /* APPLE LOCAL */
OPT_OSABI /* APPLE LOCAL */
};
static struct option long_options[] =
{
#if defined(TUI)
{"tui", no_argument, 0, OPT_TUI},
#endif
{"xdb", no_argument, &xdb_commands, 1},
{"dbx", no_argument, &dbx_commands, 1},
{"readnow", no_argument, &readnow_symbol_files, 1},
{"r", no_argument, &readnow_symbol_files, 1},
{"quiet", no_argument, &quiet, 1},
{"q", no_argument, &quiet, 1},
{"silent", no_argument, &quiet, 1},
{"nx", no_argument, &inhibit_gdbinit, 1},
{"n", no_argument, &inhibit_gdbinit, 1},
{"batch", no_argument, &batch, 1},
{"epoch", no_argument, &epoch_interface, 1},
/* This is a synonym for "--annotate=1". --annotate is now preferred,
but keep this here for a long time because people will be running
emacses which use --fullname. */
{"fullname", no_argument, 0, 'f'},
{"f", no_argument, 0, 'f'},
{"annotate", required_argument, 0, OPT_ANNOTATE},
{"help", no_argument, &print_help, 1},
{"se", required_argument, 0, OPT_SE},
{"symbols", required_argument, 0, 's'},
{"s", required_argument, 0, 's'},
{"exec", required_argument, 0, 'e'},
{"e", required_argument, 0, 'e'},
{"core", required_argument, 0, 'c'},
{"c", required_argument, 0, 'c'},
{"pid", required_argument, 0, 'p'},
{"p", required_argument, 0, 'p'},
{"command", required_argument, 0, 'x'},
{"version", no_argument, &print_version, 1},
{"x", required_argument, 0, 'x'},
#ifdef GDBTK
{"tclcommand", required_argument, 0, 'z'},
{"enable-external-editor", no_argument, 0, 'y'},
{"editor-command", required_argument, 0, 'w'},
#endif
{"ui", required_argument, 0, 'i'},
{"interpreter", required_argument, 0, 'i'},
{"i", required_argument, 0, 'i'},
{"directory", required_argument, 0, 'd'},
{"d", required_argument, 0, 'd'},
{"cd", required_argument, 0, OPT_CD},
{"tty", required_argument, 0, 't'},
{"baud", required_argument, 0, 'b'},
{"b", required_argument, 0, 'b'},
{"nw", no_argument, NULL, OPT_NOWINDOWS},
{"nowindows", no_argument, NULL, OPT_NOWINDOWS},
{"w", no_argument, NULL, OPT_WINDOWS},
{"windows", no_argument, NULL, OPT_WINDOWS},
{"statistics", no_argument, 0, OPT_STATISTICS},
{"write", no_argument, &write_files, 1},
{"args", no_argument, &set_args, 1},
/* APPLE LOCAL: */
{"waitfor", required_argument, 0, OPT_WAITFOR},
/* APPLE LOCAL: */
{"arch", required_argument, 0, OPT_ARCH},
/* APPLE LOCAL: */
{"osabi", required_argument, 0, OPT_OSABI},
{"l", required_argument, 0, 'l'},
{0, no_argument, 0, 0}
};
while (1)
{
int option_index;
c = getopt_long_only (argc, argv, "",
long_options, &option_index);
if (c == EOF || set_args)
break;
/* Long option that takes an argument. */
if (c == 0 && long_options[option_index].flag == 0)
c = long_options[option_index].val;
switch (c)
{
case 0:
/* Long option that just sets a flag. */
break;
case OPT_SE:
symarg = optarg;
execarg = optarg;
break;
case OPT_CD:
cdarg = optarg;
break;
case OPT_ANNOTATE:
/* FIXME: what if the syntax is wrong (e.g. not digits)? */
annotation_level = atoi (optarg);
break;
case OPT_STATISTICS:
/* Enable the display of both time and space usage. */
display_time = 1;
display_space = 1;
break;
case OPT_TUI:
/* --tui is equivalent to -i=tui. */
xfree (interpreter_p);
interpreter_p = xstrdup ("tui");
break;
case OPT_WINDOWS:
/* FIXME: cagney/2003-03-01: Not sure if this option is
actually useful, and if it is, what it should do. */
use_windows = 1;
break;
case OPT_NOWINDOWS:
/* -nw is equivalent to -i=console. */
xfree (interpreter_p);
interpreter_p = xstrdup (INTERP_CONSOLE);
use_windows = 0;
break;
/* APPLE LOCAL: */
case OPT_WAITFOR:
attach_waitfor = (char *) xmalloc (12 + strlen (optarg));
sprintf (attach_waitfor, "-waitfor \"%s\"", optarg);
break;
/* APPLE LOCAL: */
case OPT_ARCH:
initial_arch = xstrdup (optarg);
break;
/* APPLE LOCAL: Set the osabi via option. This option was
added along with a modification to the gdb driver shell script
for armv6. Binaries with the "arm" architecture (ARM v4T)
and "armv6" (ARM v6) can be inter mixed on armv6 capaable
targets since all instructions in the ARM v4T instruction set
are present in the ARM v6 instruction set. The same gdb
executable is used for both, and the osabi set/show variable
controls which gets used for cross targets. We need to set this
variable prior to loading any executables so that the correct
slice of a fat file can be selected. Now gdb can be launched
with the "armv6" arch along with an executable and the correct
slice will be selected:
gdb -arch armv6 <file> */
case OPT_OSABI:
osabiarg = optarg;
break;
/* APPLE LOCAL END */
case 'f':
annotation_level = 1;
/* We have probably been invoked from emacs. Disable window interface. */
use_windows = 0;
break;
case 's':
symarg = optarg;
break;
case 'e':
execarg = optarg;
break;
case 'c':
corearg = optarg;
break;
case 'p':
/* "corearg" is shared by "--core" and "--pid" */
corearg = optarg;
break;
case 'x':
cmdarg[ncmd++] = optarg;
if (ncmd >= cmdsize)
{
cmdsize *= 2;
cmdarg = (char **) xrealloc ((char *) cmdarg,
cmdsize * sizeof (*cmdarg));
}
break;
#ifdef GDBTK
case 'z':
{
extern int gdbtk_test (char *);
if (!gdbtk_test (optarg))
{
fprintf_unfiltered (gdb_stderr, _("%s: unable to load tclcommand file \"%s\""),
argv[0], optarg);
exit (1);
}
break;
}
case 'y':
/* Backwards compatibility only. */
break;
case 'w':
{
external_editor_command = xstrdup (optarg);
break;
}
#endif /* GDBTK */
case 'i':
xfree (interpreter_p);
interpreter_p = xstrdup (optarg);
break;
case 'd':
dirarg[ndir++] = optarg;
if (ndir >= dirsize)
{
dirsize *= 2;
dirarg = (char **) xrealloc ((char *) dirarg,
dirsize * sizeof (*dirarg));
}
break;
case 't':
ttyarg = optarg;
break;
case 'q':
quiet = 1;
break;
case 'b':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set baud rate to `%s'.\n"), optarg);
else
baud_rate = i;
}
break;
case 'l':
{
int i;
char *p;
i = strtol (optarg, &p, 0);
if (i == 0 && p == optarg)
/* Don't use *_filtered or warning() (which relies on
current_target) until after initialize_all_files(). */
fprintf_unfiltered
(gdb_stderr,
_("warning: could not set timeout limit to `%s'.\n"), optarg);
else
remote_timeout = i;
}
break;
case '?':
fprintf_unfiltered (gdb_stderr,
_("Use `%s --help' for a complete list of options.\n"),
argv[0]);
exit (1);
}
}
/* If --help or --version, disable window interface. */
if (print_help || print_version)
{
use_windows = 0;
}
if (set_args)
{
/* The remaining options are the command-line options for the
inferior. The first one is the sym/exec file, and the rest
are arguments. */
if (optind >= argc)
{
fprintf_unfiltered (gdb_stderr,
_("%s: `--args' specified but no program specified\n"),
argv[0]);
exit (1);
}
symarg = argv[optind];
execarg = argv[optind];
++optind;
set_inferior_args_vector (argc - optind, &argv[optind]);
}
else
{
/* OK, that's all the options. The other arguments are filenames. */
count = 0;
for (; optind < argc; optind++)
switch (++count)
{
case 1:
symarg = argv[optind];
execarg = argv[optind];
break;
case 2:
/* The documentation says this can be a "ProcID" as well.
We will try it as both a corefile and a pid. */
corearg = argv[optind];
break;
case 3:
fprintf_unfiltered (gdb_stderr,
_("Excess command line arguments ignored. (%s%s)\n"),
argv[optind], (optind == argc - 1) ? "" : " ...");
break;
}
}
if (batch)
quiet = 1;
}
/* Initialize all files. Give the interpreter a chance to take
control of the console via the deprecated_init_ui_hook (). */
gdb_init (argv[0]);
/* Do these (and anything which might call wrap_here or *_filtered)
after initialize_all_files() but before the interpreter has been
installed. Otherwize the help/version messages will be eaten by
the interpreter's output handler. */
if (print_version)
{
print_gdb_version (gdb_stdout);
wrap_here ("");
printf_filtered ("\n");
exit (0);
}
if (print_help)
{
print_gdb_help (gdb_stdout);
fputs_unfiltered ("\n", gdb_stdout);
exit (0);
}
/* FIXME: cagney/2003-02-03: The big hack (part 1 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message before the interpreter is installed. That way
it isn't encapsulated in MI output. */
if (!quiet && strcmp (interpreter_p, INTERP_MI1) == 0)
{
/* APPLE LOCAL begin don't print dots */
/* Print all the junk at the top. */
print_gdb_version (gdb_stdout);
printf_filtered ("\n");
/* APPLE LOCAL end don't print dots */
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
/* APPLE LOCAL begin */
if (state_change_hook)
{
state_change_hook (STATE_ACTIVE);
}
/* APPLE LOCAL end */
/* Install the default UI. All the interpreters should have had a
look at things by now. Initialize the default interpreter. */
{
/* Find it. */
struct interp *interp = interp_lookup (interpreter_p);
if (interp == NULL)
error (_("Interpreter `%s' unrecognized"), interpreter_p);
/* Install it. */
/* APPLE LOCAL clarity */
if (interp_set (interp) == NULL)
{
fprintf_unfiltered (gdb_stderr,
"Interpreter `%s' failed to initialize.\n",
interpreter_p);
exit (1);
}
}
/* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message after the interpreter is installed when it is
any sane interpreter. */
if (!quiet && !current_interp_named_p (INTERP_MI1))
{
/* Print all the junk at the top, with trailing "..." if we are about
to read a symbol file (possibly slowly). */
print_gdb_version (gdb_stdout);
if (symarg)
printf_filtered ("..");
wrap_here ("");
gdb_flush (gdb_stdout); /* Force to screen during slow operations */
}
error_pre_print = "\n\n";
quit_pre_print = error_pre_print;
/* We may get more than one warning, don't double space all of them... */
warning_pre_print = _("\nwarning: ");
/* APPLE LOCAL begin move inits up */
/* Make sure that they are zero in case one of them fails (this
guarantees that they won't match if either exists). */
memset (&homebuf, 0, sizeof (struct stat));
memset (&cwdbuf, 0, sizeof (struct stat));
/* APPLE LOCAL end move inits up */
/* APPLE LOCAL begin global gdbinit */
memset (&globalbuf, 0, sizeof (struct stat));
stat (gdbinit_global, &globalbuf);
if (!inhibit_gdbinit)
{
/* if (!SET_TOP_LEVEL ()) */
source_file (gdbinit_global, 0);
}
do_cleanups (ALL_CLEANUPS);
/* APPLE LOCAL end global gdbinit */
/* APPLE LOCAL: Set the $_Xcode convenience variable at '0' before sourcing
any .gdbinit files. Xcode will override this to 1 when it is launching
gdb but we need to start with a value of 0 so .gdbinit files can use it
in conditional expressions. */
set_internalvar (lookup_internalvar ("_Xcode"),
value_from_longest (builtin_type_int, (LONGEST) 0));
/* Read and execute $HOME/.gdbinit file, if it exists. This is done
*before* all the command line arguments are processed; it sets
global parameters, which are independent of what file you are
debugging or what directory you are in. */
homedir = getenv ("HOME");
if (homedir)
{
char *homeinit = xstrprintf ("%s/%s", homedir, gdbinit);
/* APPLE LOCAL move inits up */
stat (homeinit, &homebuf);
/* APPLE LOCAL gdbinit */
if (!inhibit_gdbinit)
if ((globalbuf.st_dev != homebuf.st_dev) || (globalbuf.st_ino != homebuf.st_ino))
{
catch_command_errors (source_file, homeinit, 0, RETURN_MASK_ALL);
}
}
/* Now perform all the actions indicated by the arguments. */
if (cdarg != NULL)
{
catch_command_errors (cd_command, cdarg, 0, RETURN_MASK_ALL);
}
for (i = 0; i < ndir; i++)
catch_command_errors (directory_command, dirarg[i], 0, RETURN_MASK_ALL);
xfree (dirarg);
/* APPLE LOCAL: If an architecture has been supplied, process it.
FIXME: Note, this is a TOTAL hack. There should be some gdbarch'y type
function that processes these options. The odd thing is that you would
want the SAME function for all the gdbarch'es that are registered, so
it actually lives a little above the gdbarch....
Not sure how to do that. So instead, I just hack... */
#if defined (USE_POSIX_SPAWN) || defined (USE_ARCH_FOR_EXEC)
if (initial_arch != NULL)
{
char *arch_string = NULL;
char *osabi_string;
#if defined (TARGET_POWERPC)
if (strcmp (initial_arch, "ppc") == 0)
{
arch_string = "powerpc:common";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "ppc64") == 0)
{
arch_string = "powerpc:common64";
osabi_string = "Darwin64";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"ppc\" or \"ppc64\"\n", initial_arch);
#elif defined (TARGET_I386)
if (strcmp (initial_arch, "i386") == 0)
{
arch_string = "i386";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "x86_64") == 0)
{
arch_string = "i386:x86-64";
osabi_string = "Darwin64";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"i386\" or \"x86_64\"\n", initial_arch);
#elif defined (TARGET_ARM)
if (strcmp (initial_arch, "arm") == 0)
{
arch_string = "arm";
osabi_string = "Darwin";
}
else if (strcmp (initial_arch, "armv6") == 0)
{
arch_string = "armv6";
osabi_string = "DarwinV6";
}
else
warning ("invalid argument \"%s\" for \"--arch\", should be one of "
"\"armv\" or \"armv6\"\n", initial_arch);
#endif
if (arch_string != NULL)
{
set_architecture_from_string (arch_string);
set_osabi_from_string (osabi_string);
}
}
#else
warning ("--arch option not supported in this gdb.");
#endif
/* APPLE LOCAL BEGIN: Set the osabi via option. */
if (osabiarg != NULL)
set_osabi_option (osabiarg);
/* APPLE LOCAL END */
if (execarg != NULL
&& symarg != NULL
&& strcmp (execarg, symarg) == 0)
{
/* The exec file and the symbol-file are the same. If we can't
open it, better only print one error message.
catch_command_errors returns non-zero on success! */
if (catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL))
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
else
{
if (execarg != NULL)
catch_command_errors (exec_file_attach, execarg, !batch, RETURN_MASK_ALL);
if (symarg != NULL)
catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
}
/* APPLE LOCAL begin */
if (state_change_hook && symarg != NULL)
{
state_change_hook (STATE_INFERIOR_LOADED);
}
/* APPLE LOCAL end */
/* APPLE LOCAL begin */
if (attach_waitfor != NULL)
{
printf_filtered ("\n");
catch_command_errors (attach_command, attach_waitfor, 0, RETURN_MASK_ALL);
}
/* After the symbol file has been read, print a newline to get us
beyond the copyright line... But errors should still set off
the error message with a (single) blank line. */
if (!quiet)
printf_filtered ("\n");
error_pre_print = "\n";
quit_pre_print = error_pre_print;
warning_pre_print = _("\nwarning: ");
if (corearg != NULL)
{
if (catch_command_errors (core_file_attach, corearg, !batch, RETURN_MASK_ALL) == 0)
{
/* See if the core file is really a PID. */
/* Be careful, we have quoted the corearg above... */
if (corearg[0] == '"')
{
int len = strlen (corearg);
if (corearg[len - 1] == '"')
{
corearg[len - 1] = '\0';
corearg += 1;
}
}
if (isdigit (corearg[0]))
catch_command_errors (attach_command, corearg, !batch, RETURN_MASK_ALL);
}
}
if (ttyarg != NULL)
catch_command_errors (tty_command, ttyarg, !batch, RETURN_MASK_ALL);
/* Error messages should no longer be distinguished with extra output. */
error_pre_print = NULL;
quit_pre_print = NULL;
warning_pre_print = _("warning: ");
/* Read the .gdbinit file in the current directory, *if* it isn't
the same as the $HOME/.gdbinit file (it should exist, also). */
stat (gdbinit, &cwdbuf);
if (!inhibit_gdbinit)
if (((globalbuf.st_dev != cwdbuf.st_dev) || (globalbuf.st_ino != cwdbuf.st_ino))
&& ((homebuf.st_dev != cwdbuf.st_dev) || (homebuf.st_ino != cwdbuf.st_ino)))
{
/* APPLE LOCAL: fix for CVE-2005-1705 */
if (cwdbuf.st_uid == getuid ())
catch_command_errors (source_file, gdbinit, 0, RETURN_MASK_ALL);
}
/* These need to be set this late in the initialization to ensure that
they are defined for the current environment. They define the
radix variables needed by a save-breakpoints file to preserve the
radix across the breakpoints restoration assuming they are restored
using the -x (-command) command line options. */
set_internalvar (lookup_internalvar ("input_radix"),
value_from_longest (builtin_type_int, (LONGEST) input_radix));
set_internalvar (lookup_internalvar ("output_radix"),
value_from_longest (builtin_type_int, (LONGEST) output_radix));
for (i = 0; i < ncmd; i++)
{
#if 0
/* NOTE: cagney/1999-11-03: SET_TOP_LEVEL() was a macro that
expanded into a call to setjmp(). */
if (!SET_TOP_LEVEL ()) /* NB: This is #if 0'd out */
{
/* NOTE: I am commenting this out, because it is not clear
where this feature is used. It is very old and
undocumented. ezannoni: 1999-05-04 */
#if 0
if (cmdarg[i][0] == '-' && cmdarg[i][1] == '\0')
read_command_file (stdin);
else
#endif
source_file (cmdarg[i], !batch);
do_cleanups (ALL_CLEANUPS);
}
#endif
catch_command_errors (source_file, cmdarg[i], !batch, RETURN_MASK_ALL);
}
xfree (cmdarg);
/* Read in the old history after all the command files have been read. */
init_history ();
if (batch)
{
if (attach_flag)
/* Either there was a problem executing the command in the
batch file aborted early, or the batch file forgot to do an
explicit detach. Explicitly detach the inferior ensuring
that there are no zombies. */
target_detach (NULL, 0);
/* We have hit the end of the batch file. */
exit (0);
}
/* Do any host- or target-specific hacks. This is used for i960 targets
to force the user to set a nindy target and spec its parameters. */
#ifdef BEFORE_MAIN_LOOP_HOOK
BEFORE_MAIN_LOOP_HOOK;
#endif
/* Show time and/or space usage. */
if (display_time)
{
long init_time = get_run_time () - time_at_startup;
printf_unfiltered (_("Startup time: %ld.%06ld\n"),
init_time / 1000000, init_time % 1000000);
}
if (display_space)
{
#ifdef HAVE_SBRK
extern char **environ;
char *lim = (char *) sbrk (0);
printf_unfiltered (_("Startup size: data size %ld\n"),
(long) (lim - (char *) &environ));
#endif
}
#if 0
/* FIXME: cagney/1999-11-06: The original main loop was like: */
while (1)
{
if (!SET_TOP_LEVEL ())
{
do_cleanups (ALL_CLEANUPS); /* Do complete cleanup */
/* GUIs generally have their own command loop, mainloop, or
whatever. This is a good place to gain control because
many error conditions will end up here via longjmp(). */
if (deprecated_command_loop_hook)
deprecated_command_loop_hook ();
else
deprecated_command_loop ();
quit_command ((char *) 0, instream == stdin);
}
}
/* NOTE: If the command_loop() returned normally, the loop would
attempt to exit by calling the function quit_command(). That
function would either call exit() or throw an error returning
control to SET_TOP_LEVEL. */
/* NOTE: The function do_cleanups() was called once each time round
the loop. The usefulness of the call isn't clear. If an error
was thrown, everything would have already been cleaned up. If
command_loop() returned normally and quit_command() was called,
either exit() or error() (again cleaning up) would be called. */
#endif
/* NOTE: cagney/1999-11-07: There is probably no reason for not
moving this loop and the code found in captured_command_loop()
into the command_loop() proper. The main thing holding back that
change - SET_TOP_LEVEL() - has been eliminated. */
while (1)
{
catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
}
/* No exit -- exit is through quit_command. */
}
/* General function to handle events in the inferior. So far it just
takes care of detecting errors reported by select() or poll(),
otherwise it assumes that all is OK, and goes on reading data from
the fd. This however may not always be what we want to do. */
void
inferior_event_handler (enum inferior_event_type event_type,
gdb_client_data client_data)
{
struct gdb_exception e;
int was_sync = 0;
switch (event_type)
{
case INF_ERROR:
printf_unfiltered (_("error detected from target.\n"));
pop_all_targets_above (file_stratum, 0);
discard_all_intermediate_continuations ();
discard_all_continuations ();
async_enable_stdin ();
break;
case INF_REG_EVENT:
/* Use catch errors for now, until the inner layers of
fetch_inferior_event (i.e. readchar) can return meaningful
error status. If an error occurs while getting an event from
the target, just get rid of the target. */
if (!catch_errors (fetch_inferior_event_wrapper,
client_data, "", RETURN_MASK_ALL))
{
pop_all_targets_above (file_stratum, 0);
discard_all_intermediate_continuations ();
discard_all_continuations ();
async_enable_stdin ();
display_gdb_prompt (0);
}
break;
case INF_EXEC_COMPLETE:
if (!non_stop)
{
/* Unregister the inferior from the event loop. This is done
so that when the inferior is not running we don't get
distracted by spurious inferior output. */
if (target_has_execution)
target_async (NULL, 0);
}
/* The call to async_enable_stdin below resets 'sync_execution'.
However, if sync_execution is 1 now, we also need to show the
prompt below, so save the current value. */
was_sync = sync_execution;
async_enable_stdin ();
/* Do all continuations associated with the whole inferior (not
a particular thread). */
if (!ptid_equal (inferior_ptid, null_ptid))
do_all_inferior_continuations ();
/* If we were doing a multi-step (eg: step n, next n), but it
got interrupted by a breakpoint, still do the pending
continuations. The continuation itself is responsible for
distinguishing the cases. The continuations are allowed to
touch the inferior memory, e.g. to remove breakpoints, so run
them before running breakpoint commands, which may resume the
target. */
if (non_stop
&& target_has_execution
&& !ptid_equal (inferior_ptid, null_ptid))
do_all_intermediate_continuations_thread (inferior_thread ());
else
do_all_intermediate_continuations ();
/* Always finish the previous command before running any
breakpoint commands. Any stop cancels the previous command.
E.g. a "finish" or "step-n" command interrupted by an
unrelated breakpoint is canceled. */
if (non_stop
&& target_has_execution
&& !ptid_equal (inferior_ptid, null_ptid))
do_all_continuations_thread (inferior_thread ());
else
do_all_continuations ();
if (current_language != expected_language
&& language_mode == language_mode_auto)
language_info (1); /* Print what changed. */
/* Don't propagate breakpoint commands errors. Either we're
stopping or some command resumes the inferior. The user will
be informed. */
TRY_CATCH (e, RETURN_MASK_ALL)
{
bpstat_do_actions ();
}
if (!was_sync
&& exec_done_display_p
&& (ptid_equal (inferior_ptid, null_ptid)
|| !is_running (inferior_ptid)))
printf_unfiltered (_("completed.\n"));
break;
case INF_EXEC_CONTINUE:
/* Is there anything left to do for the command issued to
complete? */
if (non_stop)
do_all_intermediate_continuations_thread (inferior_thread ());
else
do_all_intermediate_continuations ();
break;
case INF_QUIT_REQ:
/* FIXME: ezannoni 1999-10-04. This call should really be a
target vector entry, so that it can be used for any kind of
targets. */
async_remote_interrupt_twice (NULL);
break;
case INF_TIMER:
default:
printf_unfiltered (_("Event type not recognized.\n"));
break;
}
}
/* General function to handle events in the inferior. So far it just
takes care of detecting errors reported by select() or poll(),
otherwise it assumes that all is OK, and goes on reading data from
the fd. This however may not always be what we want to do. */
void
inferior_event_handler (enum inferior_event_type event_type,
gdb_client_data client_data)
{
struct cleanup *cleanup_if_error = make_bpstat_clear_actions_cleanup ();
switch (event_type)
{
case INF_REG_EVENT:
/* Use catch errors for now, until the inner layers of
fetch_inferior_event (i.e. readchar) can return meaningful
error status. If an error occurs while getting an event from
the target, just cancel the current command. */
if (!catch_errors (fetch_inferior_event_wrapper,
client_data, "", RETURN_MASK_ALL))
{
bpstat_clear_actions ();
do_all_intermediate_continuations (1);
do_all_continuations (1);
async_enable_stdin ();
display_gdb_prompt (0);
}
break;
case INF_EXEC_COMPLETE:
if (!non_stop)
{
/* Unregister the inferior from the event loop. This is done
so that when the inferior is not running we don't get
distracted by spurious inferior output. */
if (target_has_execution)
target_async (NULL, 0);
}
/* Do all continuations associated with the whole inferior (not
a particular thread). */
if (!ptid_equal (inferior_ptid, null_ptid))
do_all_inferior_continuations (0);
/* If we were doing a multi-step (eg: step n, next n), but it
got interrupted by a breakpoint, still do the pending
continuations. The continuation itself is responsible for
distinguishing the cases. The continuations are allowed to
touch the inferior memory, e.g. to remove breakpoints, so run
them before running breakpoint commands, which may resume the
target. */
if (non_stop
&& target_has_execution
&& !ptid_equal (inferior_ptid, null_ptid))
do_all_intermediate_continuations_thread (inferior_thread (), 0);
else
do_all_intermediate_continuations (0);
/* Always finish the previous command before running any
breakpoint commands. Any stop cancels the previous command.
E.g. a "finish" or "step-n" command interrupted by an
unrelated breakpoint is canceled. */
if (non_stop
&& target_has_execution
&& !ptid_equal (inferior_ptid, null_ptid))
do_all_continuations_thread (inferior_thread (), 0);
else
do_all_continuations (0);
/* When running a command list (from a user command, say), these
are only run when the command list is all done. */
if (interpreter_async)
{
volatile struct gdb_exception e;
check_frame_language_change ();
/* Don't propagate breakpoint commands errors. Either we're
stopping or some command resumes the inferior. The user will
be informed. */
TRY_CATCH (e, RETURN_MASK_ALL)
{
bpstat_do_actions ();
}
exception_print (gdb_stderr, e);
}
break;
case INF_EXEC_CONTINUE:
/* Is there anything left to do for the command issued to
complete? */
if (non_stop)
do_all_intermediate_continuations_thread (inferior_thread (), 0);
else
do_all_intermediate_continuations (0);
break;
case INF_TIMER:
default:
printf_unfiltered (_("Event type not recognized.\n"));
break;
}
discard_cleanups (cleanup_if_error);
}
static void
tui_command_loop (void *data)
{
/* If we are using readline, set things up and display the first
prompt, otherwise just print the prompt. */
if (async_command_editing_p)
{
int length;
char *a_prompt;
char *gdb_prompt = get_prompt ();
/* Tell readline what the prompt to display is and what function
it will need to call after a whole line is read. This also
displays the first prompt. */
length = strlen (PREFIX (0))
+ strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
a_prompt = (char *) alloca (length);
strcpy (a_prompt, PREFIX (0));
strcat (a_prompt, gdb_prompt);
strcat (a_prompt, SUFFIX (0));
rl_callback_handler_install (a_prompt, input_handler);
}
else
display_gdb_prompt (0);
/* Loop until there is nothing to do. This is the entry point to the
event loop engine. gdb_do_one_event, called via catch_errors()
will process one event for each invocation. It blocks waits for
an event and then processes it. >0 when an event is processed, 0
when catch_errors() caught an error and <0 when there are no
longer any event sources registered. */
while (1)
{
int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
if (result < 0)
break;
/* Update gdb output according to TUI mode. Since catch_errors
preserves the uiout from changing, this must be done at top
level of event loop. */
if (tui_active)
uiout = tui_out;
else
uiout = tui_old_uiout;
if (result == 0)
{
/* If any exception escaped to here, we better enable
stdin. Otherwise, any command that calls async_disable_stdin,
and then throws, will leave stdin inoperable. */
async_enable_stdin ();
/* FIXME: this should really be a call to a hook that is
interface specific, because interfaces can display the
prompt in their own way. */
display_gdb_prompt (0);
/* This call looks bizarre, but it is required. If the user
entered a command that caused an error,
after_char_processing_hook won't be called from
rl_callback_read_char_wrapper. Using a cleanup there
won't work, since we want this function to be called
after a new prompt is printed. */
if (after_char_processing_hook)
(*after_char_processing_hook) ();
/* Maybe better to set a flag to be checked somewhere as to
whether display the prompt or not. */
}
}
/* We are done with the event loop. There are no more event sources
to listen to. So we exit GDB. */
return;
}
