Merge GDB 7.5.1

gdb/remote-m32r-sdi.c

 /* Remote debugging interface for M32R/SDI.
 
    Copyright (C) 2003-2012 Free Software Foundation, Inc.
 
    Contributed by Renesas Technology Co.
    Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
 
    This file is part of GDB.
 
    This program is free software; you can redistribute it and/or modify
@@ skipping 163 matching lines @@
   if (c != '+')                 /* error */
     return -1;
 
   return 0;
 }
 
 /* Send data to the target and check an ack packet.  */
 static int
 send_data (void *buf, int len)
 {
-  int ret;
-
   if (!sdi_desc)
     return -1;
 
   if (serial_write (sdi_desc, buf, len) != 0)
     return -1;
 
   if (get_ack () == -1)
     return -1;
 
   return len;
@@ skipping 249 matching lines @@
 
   inferior_ptid = null_ptid;
   delete_thread_silent (remote_m32r_ptid);
   return;
 }
 
 /* Tell the remote machine to resume.  */
 
 static void
 m32r_resume (struct target_ops *ops,
-             ptid_t ptid, int step, enum target_signal sig)
+             ptid_t ptid, int step, enum gdb_signal sig)
 {
   unsigned long pc_addr, bp_addr, ab_addr;
   int ib_breakpoints;
   unsigned char buf[13];
   int i;
 
   if (remote_debug)
     {
       if (step)
         fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(step)\n");
@@ skipping 234 matching lines @@
 
 static ptid_t
 m32r_wait (struct target_ops *ops,
            ptid_t ptid, struct target_waitstatus *status, int options)
 {
   static RETSIGTYPE (*prev_sigint) ();
   unsigned long bp_addr, pc_addr;
   int ib_breakpoints;
   long i;
   unsigned char buf[13];
-  unsigned long val;
   int ret, c;
 
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
 
   status->kind = TARGET_WAITKIND_EXITED;
-  status->value.sig = TARGET_SIGNAL_0;
+  status->value.sig = GDB_SIGNAL_0;
 
   interrupted = 0;
   prev_sigint = signal (SIGINT, gdb_cntrl_c);
 
   /* Wait for ready.  */
   buf[0] = SDI_WAIT_FOR_READY;
   if (serial_write (sdi_desc, buf, 1) != 0)
     error (_("Remote connection closed"));
 
   while (1)
     {
       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
       if (c < 0)
         error (_("Remote connection closed"));
 
       if (c == '-')             /* error */
         {
           status->kind = TARGET_WAITKIND_STOPPED;
-          status->value.sig = TARGET_SIGNAL_HUP;
+          status->value.sig = GDB_SIGNAL_HUP;
           return inferior_ptid;
         }
       else if (c == '+')        /* stopped */
         break;
 
       if (interrupted)
         ret = serial_write (sdi_desc, "!", 1);  /* packet to interrupt */
       else
         ret = serial_write (sdi_desc, ".", 1);  /* packet to wait */
       if (ret != 0)
         error (_("Remote connection closed"));
     }
 
   status->kind = TARGET_WAITKIND_STOPPED;
   if (interrupted)
-    status->value.sig = TARGET_SIGNAL_INT;
+    status->value.sig = GDB_SIGNAL_INT;
   else
-    status->value.sig = TARGET_SIGNAL_TRAP;
+    status->value.sig = GDB_SIGNAL_TRAP;
 
   interrupted = 0;
   signal (SIGINT, prev_sigint);
 
   check_mmu_status ();
 
   /* Recover parallel bit.  */
   if (last_pc_addr != 0xffffffff)
     {
       buf[0] = SDI_WRITE_MEMORY;
@@ skipping 113 matching lines @@
 
 /* Terminate the open connection to the remote debugger.
    Use this when you want to detach and do something else
    with your gdb.  */
 static void
 m32r_detach (struct target_ops *ops, char *args, int from_tty)
 {
   if (remote_debug)
     fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
 
-  m32r_resume (ops, inferior_ptid, 0, TARGET_SIGNAL_0);
+  m32r_resume (ops, inferior_ptid, 0, GDB_SIGNAL_0);
 
   /* Calls m32r_close to do the real work.  */
   pop_target ();
   if (from_tty)
     fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
                         target_shortname);
 }
 
 /* Return the id of register number REGNO.  */
 
@@ skipping 319 matching lines @@
 {
   struct cleanup *old_chain;
   asection *section;
   bfd *pbfd;
   bfd_vma entry;
   char *filename;
   int quiet;
   int nostart;
   struct timeval start_time, end_time;
   unsigned long data_count;     /* Number of bytes transferred to memory.  */
-  int ret;
   static RETSIGTYPE (*prev_sigint) ();
 
   /* for direct tcp connections, we can do a fast binary download.  */
   quiet = 0;
   nostart = 0;
   filename = NULL;
 
   while (*args != '\000')
     {
       char *arg;
@@ skipping 458 matching lines @@
 
   add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
            _("Set breakpoints by IB break."));
   add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
            _("Set breakpoints by dbt."));
 
   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
      isn't 0.  */
   remote_m32r_ptid = ptid_build (42000, 0, 42000);
 }