Subversion Repositories openrisc_me

/* Top level stuff for GDB, the GNU debugger.

   Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2007, 2008

   Free Software Foundation, Inc.

   Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.

   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/>. */

#include "defs.h"

#include "top.h"

#include "inferior.h"

#include "target.h"

#include "terminal.h"           /* for job_control */

#include "event-loop.h"

#include "event-top.h"

#include "interps.h"

#include <signal.h>

#include "exceptions.h"

#include "cli/cli-script.h"     /* for reset_command_nest_depth */

/* For dont_repeat() */

#include "gdbcmd.h"

/* readline include files */

#include "readline/readline.h"

#include "readline/history.h"

/* readline defines this.  */

#undef savestring

static void rl_callback_read_char_wrapper (gdb_client_data client_data);

static void command_line_handler (char *rl);

static void command_line_handler_continuation (struct continuation_arg *arg);

static void change_line_handler (void);

static void change_annotation_level (void);

static void command_handler (char *command);

/* Signal handlers. */

#ifdef SIGQUIT

static void handle_sigquit (int sig);

#endif

#ifdef SIGHUP

static void handle_sighup (int sig);

#endif

static void handle_sigfpe (int sig);

#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)

static void handle_sigwinch (int sig);

#endif

/* Functions to be invoked by the event loop in response to

   signals. */

#if defined (SIGQUIT) || defined (SIGHUP)

static void async_do_nothing (gdb_client_data);

#endif

#ifdef SIGHUP

static void async_disconnect (gdb_client_data);

#endif

static void async_float_handler (gdb_client_data);

#ifdef STOP_SIGNAL

static void async_stop_sig (gdb_client_data);

#endif

/* Readline offers an alternate interface, via callback

   functions. These are all included in the file callback.c in the

   readline distribution.  This file provides (mainly) a function, which

   the event loop uses as callback (i.e. event handler) whenever an event

   is detected on the standard input file descriptor.

   readline_callback_read_char is called (by the GDB event loop) whenever

   there is a new character ready on the input stream. This function

   incrementally builds a buffer internal to readline where it

   accumulates the line read up to the point of invocation.  In the

   special case in which the character read is newline, the function

   invokes a GDB supplied callback routine, which does the processing of

   a full command line.  This latter routine is the asynchronous analog

   of the old command_line_input in gdb. Instead of invoking (and waiting

   for) readline to read the command line and pass it back to

   command_loop for processing, the new command_line_handler function has

   the command line already available as its parameter.  INPUT_HANDLER is

   to be set to the function that readline will invoke when a complete

   line of input is ready.  CALL_READLINE is to be set to the function

   that readline offers as callback to the event_loop. */

void (*input_handler) (char *);

void (*call_readline) (gdb_client_data);

/* Important variables for the event loop. */

/* This is used to determine if GDB is using the readline library or

   its own simplified form of readline. It is used by the asynchronous

   form of the set editing command.

   ezannoni: as of 1999-04-29 I expect that this

   variable will not be used after gdb is changed to use the event

   loop as default engine, and event-top.c is merged into top.c. */

int async_command_editing_p;

/* This variable contains the new prompt that the user sets with the

   set prompt command. */

char *new_async_prompt;

/* This is the annotation suffix that will be used when the

   annotation_level is 2. */

char *async_annotation_suffix;

/* This is used to display the notification of the completion of an

   asynchronous execution command. */

int exec_done_display_p = 0;

/* This is the file descriptor for the input stream that GDB uses to

   read commands from. */

int input_fd;

/* This is the prompt stack. Prompts will be pushed on the stack as

   needed by the different 'kinds' of user inputs GDB is asking

   for. See event-loop.h. */

struct prompts the_prompts;

/* signal handling variables */

/* Each of these is a pointer to a function that the event loop will

   invoke if the corresponding signal has received. The real signal

   handlers mark these functions as ready to be executed and the event

   loop, in a later iteration, calls them. See the function

   invoke_async_signal_handler. */

void *sigint_token;

#ifdef SIGHUP

void *sighup_token;

#endif

#ifdef SIGQUIT

void *sigquit_token;

#endif

void *sigfpe_token;

#if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)

void *sigwinch_token;

#endif

#ifdef STOP_SIGNAL

void *sigtstp_token;

#endif

/* Structure to save a partially entered command.  This is used when

   the user types '\' at the end of a command line. This is necessary

   because each line of input is handled by a different call to

   command_line_handler, and normally there is no state retained

   between different calls. */

int more_to_come = 0;

struct readline_input_state

  {

    char *linebuffer;

    char *linebuffer_ptr;

  }

readline_input_state;

/* This hook is called by rl_callback_read_char_wrapper after each

   character is processed.  */

void (*after_char_processing_hook) ();

/* Wrapper function for calling into the readline library. The event

   loop expects the callback function to have a paramter, while readline

   expects none. */

static void

rl_callback_read_char_wrapper (gdb_client_data client_data)

{

  rl_callback_read_char ();

  if (after_char_processing_hook)

    (*after_char_processing_hook) ();

}

/* Initialize all the necessary variables, start the event loop,

   register readline, and stdin, start the loop. */

void

cli_command_loop (void)

{

  /* 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);

  /* Now it's time to start the event loop. */

  start_event_loop ();

}

/* Change the function to be invoked every time there is a character

   ready on stdin. This is used when the user sets the editing off,

   therefore bypassing readline, and letting gdb handle the input

   itself, via gdb_readline2. Also it is used in the opposite case in

   which the user sets editing on again, by restoring readline

   handling of the input. */

static void

change_line_handler (void)

{

  /* NOTE: this operates on input_fd, not instream. If we are reading

     commands from a file, instream will point to the file. However in

     async mode, we always read commands from a file with editing

     off. This means that the 'set editing on/off' will have effect

     only on the interactive session. */

  if (async_command_editing_p)

    {

      /* Turn on editing by using readline. */

      call_readline = rl_callback_read_char_wrapper;

      input_handler = command_line_handler;

    }

  else

    {

      /* Turn off editing by using gdb_readline2. */

      rl_callback_handler_remove ();

      call_readline = gdb_readline2;

      /* Set up the command handler as well, in case we are called as

         first thing from .gdbinit. */

      input_handler = command_line_handler;

    }

}

/* Displays the prompt. The prompt that is displayed is the current

   top of the prompt stack, if the argument NEW_PROMPT is

   0. Otherwise, it displays whatever NEW_PROMPT is. This is used

   after each gdb command has completed, and in the following cases:

   1. when the user enters a command line which is ended by '\'

   indicating that the command will continue on the next line.

   In that case the prompt that is displayed is the empty string.

   2. When the user is entering 'commands' for a breakpoint, or

   actions for a tracepoint. In this case the prompt will be '>'

   3. Other????

   FIXME: 2. & 3. not implemented yet for async. */

void

display_gdb_prompt (char *new_prompt)

{

  int prompt_length = 0;

  char *gdb_prompt = get_prompt ();

  /* Reset the nesting depth used when trace-commands is set.  */

  reset_command_nest_depth ();

  /* Each interpreter has its own rules on displaying the command

     prompt.  */

  if (!current_interp_display_prompt_p ())

    return;

  if (target_executing && sync_execution)

    {

      /* This is to trick readline into not trying to display the

         prompt.  Even though we display the prompt using this

         function, readline still tries to do its own display if we

         don't call rl_callback_handler_install and

         rl_callback_handler_remove (which readline detects because a

         global variable is not set). If readline did that, it could

         mess up gdb signal handlers for SIGINT.  Readline assumes

         that between calls to rl_set_signals and rl_clear_signals gdb

         doesn't do anything with the signal handlers. Well, that's

         not the case, because when the target executes we change the

         SIGINT signal handler. If we allowed readline to display the

         prompt, the signal handler change would happen exactly

         between the calls to the above two functions.

         Calling rl_callback_handler_remove(), does the job. */

      rl_callback_handler_remove ();

      return;

    }

  if (!new_prompt)

    {

      /* Just use the top of the prompt stack. */

      prompt_length = strlen (PREFIX (0)) +

        strlen (SUFFIX (0)) +

        strlen (gdb_prompt) + 1;

      new_prompt = (char *) alloca (prompt_length);

      /* Prefix needs to have new line at end. */

      strcpy (new_prompt, PREFIX (0));

      strcat (new_prompt, gdb_prompt);

      /* Suffix needs to have a new line at end and \032 \032 at

         beginning. */

      strcat (new_prompt, SUFFIX (0));

    }

  if (async_command_editing_p)

    {

      rl_callback_handler_remove ();

      rl_callback_handler_install (new_prompt, input_handler);

    }

  /* new_prompt at this point can be the top of the stack or the one passed in */

  else if (new_prompt)

    {

      /* Don't use a _filtered function here.  It causes the assumed

         character position to be off, since the newline we read from

         the user is not accounted for.  */

      fputs_unfiltered (new_prompt, gdb_stdout);

      gdb_flush (gdb_stdout);

    }

}

/* Used when the user requests a different annotation level, with

   'set annotate'. It pushes a new prompt (with prefix and suffix) on top

   of the prompt stack, if the annotation level desired is 2, otherwise

   it pops the top of the prompt stack when we want the annotation level

   to be the normal ones (1 or 0). */

static void

change_annotation_level (void)

{

  char *prefix, *suffix;

  if (!PREFIX (0) || !PROMPT (0) || !SUFFIX (0))

    {

      /* The prompt stack has not been initialized to "", we are

         using gdb w/o the --async switch */

      warning (_("Command has same effect as set annotate"));

      return;

    }

  if (annotation_level > 1)

    {

      if (!strcmp (PREFIX (0), "") && !strcmp (SUFFIX (0), ""))

        {

          /* Push a new prompt if the previous annotation_level was not >1. */

          prefix = (char *) alloca (strlen (async_annotation_suffix) + 10);

          strcpy (prefix, "\n\032\032pre-");

          strcat (prefix, async_annotation_suffix);

          strcat (prefix, "\n");

          suffix = (char *) alloca (strlen (async_annotation_suffix) + 6);

          strcpy (suffix, "\n\032\032");

          strcat (suffix, async_annotation_suffix);

          strcat (suffix, "\n");

          push_prompt (prefix, (char *) 0, suffix);

        }

    }

  else

    {

      if (strcmp (PREFIX (0), "") && strcmp (SUFFIX (0), ""))

        {

          /* Pop the top of the stack, we are going back to annotation < 1. */

          pop_prompt ();

        }

    }

}

/* Pushes a new prompt on the prompt stack. Each prompt has three

   parts: prefix, prompt, suffix. Usually prefix and suffix are empty

   strings, except when the annotation level is 2. Memory is allocated

   within savestring for the new prompt. */

void

push_prompt (char *prefix, char *prompt, char *suffix)

{

  the_prompts.top++;

  PREFIX (0) = savestring (prefix, strlen (prefix));

  /* Note that this function is used by the set annotate 2

     command. This is why we take care of saving the old prompt

     in case a new one is not specified. */

  if (prompt)

    PROMPT (0) = savestring (prompt, strlen (prompt));

  else

    PROMPT (0) = savestring (PROMPT (-1), strlen (PROMPT (-1)));

  SUFFIX (0) = savestring (suffix, strlen (suffix));

}

/* Pops the top of the prompt stack, and frees the memory allocated for it. */

void

pop_prompt (void)

{

  /* If we are not during a 'synchronous' execution command, in which

     case, the top prompt would be empty. */

  if (strcmp (PROMPT (0), ""))

    /* This is for the case in which the prompt is set while the

       annotation level is 2. The top prompt will be changed, but when

       we return to annotation level < 2, we want that new prompt to be

       in effect, until the user does another 'set prompt'. */

    if (strcmp (PROMPT (0), PROMPT (-1)))

      {

        xfree (PROMPT (-1));

        PROMPT (-1) = savestring (PROMPT (0), strlen (PROMPT (0)));

      }

  xfree (PREFIX (0));

  xfree (PROMPT (0));

  xfree (SUFFIX (0));

  the_prompts.top--;

}

/* When there is an event ready on the stdin file desriptor, instead

   of calling readline directly throught the callback function, or

   instead of calling gdb_readline2, give gdb a chance to detect

   errors and do something. */

void

stdin_event_handler (int error, gdb_client_data client_data)

{

  if (error)

    {

      printf_unfiltered (_("error detected on stdin\n"));

      delete_file_handler (input_fd);

      discard_all_continuations ();

      /* If stdin died, we may as well kill gdb. */

      quit_command ((char *) 0, stdin == instream);

    }

  else

    (*call_readline) (client_data);

}

/* Re-enable stdin after the end of an execution command in

   synchronous mode, or after an error from the target, and we aborted

   the exec operation. */

void

async_enable_stdin (void *dummy)

{

  /* See NOTE in async_disable_stdin() */

  /* FIXME: cagney/1999-09-27: Call this before clearing

     sync_execution.  Current target_terminal_ours() implementations

     check for sync_execution before switching the terminal. */

  target_terminal_ours ();

  pop_prompt ();

  sync_execution = 0;

}

/* Disable reads from stdin (the console) marking the command as

   synchronous. */

void

async_disable_stdin (void)

{

  sync_execution = 1;

  push_prompt ("", "", "");

  /* FIXME: cagney/1999-09-27: At present this call is technically

     redundant since infcmd.c and infrun.c both already call

     target_terminal_inferior().  As the terminal handling (in

     sync/async mode) is refined, the duplicate calls can be

     eliminated (Here or in infcmd.c/infrun.c). */

  target_terminal_inferior ();

  /* Add the reinstate of stdin to the list of cleanups to be done

     in case the target errors out and dies. These cleanups are also

     done in case of normal successful termination of the execution

     command, by complete_execution(). */

  make_exec_error_cleanup (async_enable_stdin, NULL);

}

/* Handles a gdb command. This function is called by

   command_line_handler, which has processed one or more input lines

   into COMMAND. */

/* NOTE: 1999-04-30 This is the asynchronous version of the command_loop

   function.  The command_loop function will be obsolete when we

   switch to use the event loop at every execution of gdb. */

static void

command_handler (char *command)

{

  struct cleanup *old_chain;

  int stdin_is_tty = ISATTY (stdin);

  struct continuation_arg *arg1;

  struct continuation_arg *arg2;

  long time_at_cmd_start;

#ifdef HAVE_SBRK

  long space_at_cmd_start = 0;

#endif

  extern int display_time;

  extern int display_space;

  quit_flag = 0;

  if (instream == stdin && stdin_is_tty)

    reinitialize_more_filter ();

  old_chain = make_cleanup (null_cleanup, 0);

  /* If readline returned a NULL command, it means that the

     connection with the terminal is gone. This happens at the

     end of a testsuite run, after Expect has hung up

     but GDB is still alive. In such a case, we just quit gdb

     killing the inferior program too. */

  if (command == 0)

    {

      printf_unfiltered ("quit\n");

      execute_command ("quit", stdin == instream);

    }

  time_at_cmd_start = get_run_time ();

  if (display_space)

    {

#ifdef HAVE_SBRK

      char *lim = (char *) sbrk (0);

      space_at_cmd_start = lim - lim_at_start;

#endif

    }

  execute_command (command, instream == stdin);

  /* Set things up for this function to be compete later, once the

     execution has completed, if we are doing an execution command,

     otherwise, just go ahead and finish. */

  if (target_can_async_p () && target_executing)

    {

      arg1 =

        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));

      arg2 =

        (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));

      arg1->next = arg2;

      arg2->next = NULL;

      arg1->data.longint = time_at_cmd_start;

#ifdef HAVE_SBRK

      arg2->data.longint = space_at_cmd_start;

#endif

      add_continuation (command_line_handler_continuation, arg1);

    }

  /* Do any commands attached to breakpoint we stopped at. Only if we

     are always running synchronously. Or if we have just executed a

     command that doesn't start the target. */

  if (!target_can_async_p () || !target_executing)

    {

      bpstat_do_actions (&stop_bpstat);

      do_cleanups (old_chain);

      if (display_time)

        {

          long cmd_time = get_run_time () - time_at_cmd_start;

          printf_unfiltered (_("Command execution time: %ld.%06ld\n"),

                             cmd_time / 1000000, cmd_time % 1000000);

        }

      if (display_space)

        {

#ifdef HAVE_SBRK

          char *lim = (char *) sbrk (0);

          long space_now = lim - lim_at_start;

          long space_diff = space_now - space_at_cmd_start;

          printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),

                             space_now,

                             (space_diff >= 0 ? '+' : '-'),

                             space_diff);

#endif

        }

    }

}

/* Do any commands attached to breakpoint we stopped at. Only if we

   are always running synchronously. Or if we have just executed a

   command that doesn't start the target. */

void

command_line_handler_continuation (struct continuation_arg *arg)

{

  extern int display_time;

  extern int display_space;

  long time_at_cmd_start  = arg->data.longint;

  long space_at_cmd_start = arg->next->data.longint;

  bpstat_do_actions (&stop_bpstat);

  /*do_cleanups (old_chain); *//*?????FIXME????? */

  if (display_time)

    {

      long cmd_time = get_run_time () - time_at_cmd_start;

      printf_unfiltered (_("Command execution time: %ld.%06ld\n"),

                         cmd_time / 1000000, cmd_time % 1000000);

    }

  if (display_space)

    {

#ifdef HAVE_SBRK

      char *lim = (char *) sbrk (0);

      long space_now = lim - lim_at_start;

      long space_diff = space_now - space_at_cmd_start;

      printf_unfiltered (_("Space used: %ld (%c%ld for this command)\n"),

                         space_now,

                         (space_diff >= 0 ? '+' : '-'),

                         space_diff);

#endif

    }

}

/* Handle a complete line of input. This is called by the callback

   mechanism within the readline library.  Deal with incomplete commands

   as well, by saving the partial input in a global buffer.  */

/* NOTE: 1999-04-30 This is the asynchronous version of the

   command_line_input function. command_line_input will become

   obsolete once we use the event loop as the default mechanism in

   GDB. */

static void

command_line_handler (char *rl)

{

  static char *linebuffer = 0;

  static unsigned linelength = 0;

  char *p;

  char *p1;

  extern char *line;

  extern int linesize;

  char *nline;

  char got_eof = 0;

  int repeat = (instream == stdin);

  if (annotation_level > 1 && instream == stdin)

    {

      printf_unfiltered (("\n\032\032post-"));

      puts_unfiltered (async_annotation_suffix);

      printf_unfiltered (("\n"));

    }

  if (linebuffer == 0)

    {

      linelength = 80;

      linebuffer = (char *) xmalloc (linelength);

    }

  p = linebuffer;

  if (more_to_come)

    {

      strcpy (linebuffer, readline_input_state.linebuffer);

      p = readline_input_state.linebuffer_ptr;

      xfree (readline_input_state.linebuffer);

      more_to_come = 0;

      pop_prompt ();

    }

#ifdef STOP_SIGNAL

  if (job_control)

    signal (STOP_SIGNAL, handle_stop_sig);

#endif

  /* Make sure that all output has been output.  Some machines may let

     you get away with leaving out some of the gdb_flush, but not all.  */

  wrap_here ("");

  gdb_flush (gdb_stdout);

  gdb_flush (gdb_stderr);

  if (source_file_name != NULL)

    ++source_line_number;

  /* If we are in this case, then command_handler will call quit

     and exit from gdb. */

  if (!rl || rl == (char *) EOF)

    {

      got_eof = 1;

      command_handler (0);

      return;                   /* Lint. */

    }

  if (strlen (rl) + 1 + (p - linebuffer) > linelength)

    {

      linelength = strlen (rl) + 1 + (p - linebuffer);

      nline = (char *) xrealloc (linebuffer, linelength);

      p += nline - linebuffer;

      linebuffer = nline;

    }

  p1 = rl;

  /* Copy line.  Don't copy null at end.  (Leaves line alone

     if this was just a newline)  */

  while (*p1)

    *p++ = *p1++;

  xfree (rl);                   /* Allocated in readline.  */

  if (p > linebuffer && *(p - 1) == '\\')

    {

      p--;                      /* Put on top of '\'.  */

      readline_input_state.linebuffer = savestring (linebuffer,

                                                    strlen (linebuffer));

      readline_input_state.linebuffer_ptr = p;

      /* We will not invoke a execute_command if there is more

         input expected to complete the command. So, we need to

         print an empty prompt here. */

      more_to_come = 1;

      push_prompt ("", "", "");

      display_gdb_prompt (0);

      return;

    }

#ifdef STOP_SIGNAL

  if (job_control)

    signal (STOP_SIGNAL, SIG_DFL);

#endif

#define SERVER_COMMAND_LENGTH 7

  server_command =

    (p - linebuffer > SERVER_COMMAND_LENGTH)

    && strncmp (linebuffer, "server ", SERVER_COMMAND_LENGTH) == 0;

  if (server_command)

    {

      /* Note that we don't set `line'.  Between this and the check in

         dont_repeat, this insures that repeating will still do the

         right thing.  */

      *p = '\0';

      command_handler (linebuffer + SERVER_COMMAND_LENGTH);