Merge GDB 7.5.1

gdb/remote-sim.c

 /* Generic remote debugging interface for simulators.
 
    Copyright (C) 1993-2002, 2004-2012 Free Software Foundation, Inc.
 
    Contributed by Cygnus Support.
    Steve Chamberlain (sac@cygnus.com).
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 100 matching lines @@
   SIM_DESC gdbsim_desc;
 
   /* This is the ptid we use for this particular simulator instance.  Its
      value is somewhat arbitrary, as the simulator target don't have a
      notion of tasks or threads, but we need something non-null to place
      in inferior_ptid.  For simulators which permit multiple instances,
      we also need a unique identifier to use for each inferior.  */
   ptid_t remote_sim_ptid;
 
   /* Signal with which to resume.  */
-  enum target_signal resume_siggnal;
+  enum gdb_signal resume_siggnal;
 
   /* Flag which indicates whether resume should step or not.  */
   int resume_step;
 };
 
 /* Flag indicating the "open" status of this module.  It's set to 1
    in gdbsim_open() and 0 in gdbsim_close().  */
 static int gdbsim_is_open = 0;
 
 /* Value of the next pid to allocate for an inferior.  As indicated
@@ skipping 78 matching lines @@
       sim_data = XZALLOC(struct sim_inferior_data);
       set_inferior_data (inf, sim_inferior_data_key, sim_data);
 
       /* Allocate a ptid for this inferior.  */
       sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
       next_pid++;
 
       /* Initialize the other instance variables.  */
       sim_data->program_loaded = 0;
       sim_data->gdbsim_desc = sim_desc;
-      sim_data->resume_siggnal = TARGET_SIGNAL_0;
+      sim_data->resume_siggnal = GDB_SIGNAL_0;
       sim_data->resume_step = 0;
     }
   else if (sim_desc)
     {
       /* This handles the case where sim_data was allocated prior to
          needing a sim instance.  */
       sim_data->gdbsim_desc = sim_desc;
     }
 
 
@@ skipping 403 matching lines @@
       arg_buf = (char *) alloca (len);
       arg_buf[0] = '\0';
       strcat (arg_buf, exec_file);
       strcat (arg_buf, " ");
       strcat (arg_buf, args);
       argv = gdb_buildargv (arg_buf);
       make_cleanup_freeargv (argv);
     }
   else
     argv = NULL;
-  sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env);
+
+  if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd, argv, env)
+      != SIM_RC_OK)
+    error (_("Unable to create sim inferior."));
 
   inferior_ptid = sim_data->remote_sim_ptid;
   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
   add_thread_silent (inferior_ptid);
 
   insert_breakpoints ();        /* Needed to get correct instruction
                                    in cache.  */
 
   clear_proceed_status ();
 }
@@ skipping 173 matching lines @@
   if (from_tty)
     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
 }
 
 /* Resume execution of the target process.  STEP says whether to single-step
    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
    to the target, or zero for no signal.  */
 
 struct resume_data
 {
-  enum target_signal siggnal;
+  enum gdb_signal siggnal;
   int step;
 };
 
 static int
 gdbsim_resume_inferior (struct inferior *inf, void *arg)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
   struct resume_data *rd = arg;
 
   if (sim_data)
     {
       sim_data->resume_siggnal = rd->siggnal;
       sim_data->resume_step = rd->step;
 
       if (remote_debug)
         printf_filtered (_("gdbsim_resume: pid %d, step %d, signal %d\n"),
                          inf->pid, rd->step, rd->siggnal);
     }
 
   /* When called from iterate_over_inferiors, a zero return causes the
      iteration process to proceed until there are no more inferiors to
      consider.  */
   return 0;
 }
 
 static void
 gdbsim_resume (struct target_ops *ops,
-               ptid_t ptid, int step, enum target_signal siggnal)
+               ptid_t ptid, int step, enum gdb_signal siggnal)
 {
   struct resume_data rd;
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 
   rd.siggnal = siggnal;
   rd.step = step;
 
   /* We don't access any sim_data members within this function.
      What's of interest is whether or not the call to
@@ skipping 140 matching lines @@
 
   switch (reason)
     {
     case sim_exited:
       status->kind = TARGET_WAITKIND_EXITED;
       status->value.integer = sigrc;
       break;
     case sim_stopped:
       switch (sigrc)
         {
-        case TARGET_SIGNAL_ABRT:
+        case GDB_SIGNAL_ABRT:
           quit ();
           break;
-        case TARGET_SIGNAL_INT:
-        case TARGET_SIGNAL_TRAP:
+        case GDB_SIGNAL_INT:
+        case GDB_SIGNAL_TRAP:
         default:
           status->kind = TARGET_WAITKIND_STOPPED;
           status->value.sig = sigrc;
           break;
         }
       break;
     case sim_signalled:
       status->kind = TARGET_WAITKIND_SIGNALLED;
       status->value.sig = sigrc;
       break;
@@ skipping 145 matching lines @@
       error (_("Not connected to the simulator target"));
     }
 
   sim_do_command (sim_data->gdbsim_desc, args);
 
   /* Invalidate the register cache, in case the simulator command does
      something funny.  */
   registers_changed ();
 }
 
-static char **
+static VEC (char_ptr) *
 sim_command_completer (struct cmd_list_element *ignore, char *text, char *word)
 {
   struct sim_inferior_data *sim_data;
+  char **tmp;
+  int i;
+  VEC (char_ptr) *result = NULL;
 
   sim_data = inferior_data (current_inferior (), sim_inferior_data_key);
   if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
     return NULL;
 
-  return sim_complete_command (sim_data->gdbsim_desc, text, word);
+  tmp = sim_complete_command (sim_data->gdbsim_desc, text, word);
+  if (tmp == NULL)
+    return NULL;
+
+  /* Transform the array into a VEC, and then free the array.  */
+  for (i = 0; tmp[i] != NULL; i++)
+    VEC_safe_push (char_ptr, result, tmp[i]);
+  xfree (tmp);
+
+  return result;
 }
 
 /* Check to see if a thread is still alive.  */
 
 static int
 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
 
@@ skipping 11 matching lines @@
    buffer.  */
 
 static char *
 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
 {
   return normal_pid_to_str (ptid);
 }
 
 /* Simulator memory may be accessed after the program has been loaded.  */
 
-int
+static int
 gdbsim_has_all_memory (struct target_ops *ops)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (!sim_data->program_loaded)
     return 0;
 
   return 1;
 }
 
-int
+static int
 gdbsim_has_memory (struct target_ops *ops)
 {
   struct sim_inferior_data *sim_data
     = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
 
   if (!sim_data->program_loaded)
     return 0;
 
   return 1;
 }
@@ skipping 44 matching lines @@
   init_gdbsim_ops ();
   add_target (&gdbsim_ops);
 
   c = add_com ("sim", class_obscure, simulator_command,
                _("Send a command to the simulator."));
   set_cmd_completer (c, sim_command_completer);
 
   sim_inferior_data_key
     = register_inferior_data_with_cleanup (sim_inferior_data_cleanup);
 }