gdb/remote-m32r-sdi.c

   1 /* Remote debugging interface for M32R/SDI.
   2
   3    Copyright 2003, 2004 Free Software Foundation, Inc.
   4
   5    Contributed by Renesas Technology Co.
   6    Written by Kei Sakamoto <sakamoto.kei@renesas.com>.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 2 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "gdbcmd.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "regcache.h"
  31 #include "gdb_string.h"
  32 #include <ctype.h>
  33 #include <signal.h>
  34 #include <netinet/in.h>
  35 #include <sys/types.h>
  36 #include <sys/time.h>
  37 #include <signal.h>
  38 #include <time.h>
  39
  40
  41 #include "serial.h"
  42
  43 /* Descriptor for I/O to remote machine.  */
  44
  45 static struct serial *sdi_desc = NULL;
  46
  47 #define SDI_TIMEOUT 30
  48
  49
  50 #define SDIPORT 3232
  51
  52 static char chip_name[64];
  53
  54 static int step_mode;
  55 static unsigned long last_pc_addr = 0xffffffff;
  56 static unsigned char last_pc_addr_data[2];
  57
  58 static int mmu_on = 0;
  59
  60 static int use_ib_breakpoints = 1;
  61
  62 #define MAX_BREAKPOINTS 1024
  63 static int max_ib_breakpoints;
  64 static unsigned long bp_address[MAX_BREAKPOINTS];
  65 static unsigned char bp_data[MAX_BREAKPOINTS][4];
  66
  67 /* dbt -> nop */
  68 static const unsigned char dbt_bp_entry[] = {
  69   0x10, 0xe0, 0x70, 0x00
  70 };
  71
  72 #define MAX_ACCESS_BREAKS 4
  73 static int max_access_breaks;
  74 static unsigned long ab_address[MAX_ACCESS_BREAKS];
  75 static unsigned int ab_type[MAX_ACCESS_BREAKS];
  76 static unsigned int ab_size[MAX_ACCESS_BREAKS];
  77 static CORE_ADDR hit_watchpoint_addr = 0;
  78
  79 static int interrupted = 0;
  80
  81 /* Forward data declarations */
  82 extern struct target_ops m32r_ops;
  83
  84
  85 /* Commands */
  86 #define SDI_OPEN                 1
  87 #define SDI_CLOSE                2
  88 #define SDI_RELEASE              3
  89 #define SDI_READ_CPU_REG         4
  90 #define SDI_WRITE_CPU_REG        5
  91 #define SDI_READ_MEMORY          6
  92 #define SDI_WRITE_MEMORY         7
  93 #define SDI_EXEC_CPU             8
  94 #define SDI_STOP_CPU             9
  95 #define SDI_WAIT_FOR_READY      10
  96 #define SDI_GET_ATTR            11
  97 #define SDI_SET_ATTR            12
  98 #define SDI_STATUS              13
  99
 100 /* Attributes */
 101 #define SDI_ATTR_NAME            1
 102 #define SDI_ATTR_BRK             2
 103 #define SDI_ATTR_ABRK            3
 104 #define SDI_ATTR_CACHE           4
 105 #define SDI_CACHE_TYPE_M32102    0
 106 #define SDI_CACHE_TYPE_CHAOS     1
 107 #define SDI_ATTR_MEM_ACCESS      5
 108 #define SDI_MEM_ACCESS_DEBUG_DMA 0
 109 #define SDI_MEM_ACCESS_MON_CODE  1
 110
 111 /* Registers */
 112 #define SDI_REG_R0               0
 113 #define SDI_REG_R1               1
 114 #define SDI_REG_R2               2
 115 #define SDI_REG_R3               3
 116 #define SDI_REG_R4               4
 117 #define SDI_REG_R5               5
 118 #define SDI_REG_R6               6
 119 #define SDI_REG_R7               7
 120 #define SDI_REG_R8               8
 121 #define SDI_REG_R9               9
 122 #define SDI_REG_R10             10
 123 #define SDI_REG_R11             11
 124 #define SDI_REG_R12             12
 125 #define SDI_REG_FP              13
 126 #define SDI_REG_LR              14
 127 #define SDI_REG_SP              15
 128 #define SDI_REG_PSW             16
 129 #define SDI_REG_CBR             17
 130 #define SDI_REG_SPI             18
 131 #define SDI_REG_SPU             19
 132 #define SDI_REG_CR4             20
 133 #define SDI_REG_EVB             21
 134 #define SDI_REG_BPC             22
 135 #define SDI_REG_CR7             23
 136 #define SDI_REG_BBPSW           24
 137 #define SDI_REG_CR9             25
 138 #define SDI_REG_CR10            26
 139 #define SDI_REG_CR11            27
 140 #define SDI_REG_CR12            28
 141 #define SDI_REG_WR              29
 142 #define SDI_REG_BBPC            30
 143 #define SDI_REG_PBP             31
 144 #define SDI_REG_ACCH            32
 145 #define SDI_REG_ACCL            33
 146 #define SDI_REG_ACC1H           34
 147 #define SDI_REG_ACC1L           35
 148
 149
 150 /* Low level communication functions */
 151
 152 /* Check an ack packet from the target */
 153 static int
 154 get_ack (void)
 155 {
 156   int c;
 157
 158   if (!sdi_desc)
 159     return -1;
 160
 161   c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 162
 163   if (c < 0)
 164     return -1;
 165
 166   if (c != '+')                 /* error */
 167     return -1;
 168
 169   return 0;
 170 }
 171
 172 /* Send data to the target and check an ack packet */
 173 static int
 174 send_data (void *buf, int len)
 175 {
 176   int ret;
 177
 178   if (!sdi_desc)
 179     return -1;
 180
 181   if (serial_write (sdi_desc, buf, len) != 0)
 182     return -1;
 183
 184   if (get_ack () == -1)
 185     return -1;
 186
 187   return len;
 188 }
 189
 190 /* Receive data from the target */
 191 static int
 192 recv_data (void *buf, int len)
 193 {
 194   int total = 0;
 195   int c;
 196
 197   if (!sdi_desc)
 198     return -1;
 199
 200   while (total < len)
 201     {
 202       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 203
 204       if (c < 0)
 205         return -1;
 206
 207       ((unsigned char *) buf)[total++] = c;
 208     }
 209
 210   return len;
 211 }
 212
 213 /* Store unsigned long parameter on packet */
 214 static void
 215 store_long_parameter (void *buf, long val)
 216 {
 217   val = htonl (val);
 218   memcpy (buf, &val, 4);
 219 }
 220
 221 static int
 222 send_cmd (unsigned char cmd)
 223 {
 224   unsigned char buf[1];
 225   buf[0] = cmd;
 226   return send_data (buf, 1);
 227 }
 228
 229 static int
 230 send_one_arg_cmd (unsigned char cmd, unsigned char arg1)
 231 {
 232   unsigned char buf[2];
 233   buf[0] = cmd;
 234   buf[1] = arg1;
 235   return send_data (buf, 2);
 236 }
 237
 238 static int
 239 send_two_arg_cmd (unsigned char cmd, unsigned char arg1, unsigned long arg2)
 240 {
 241   unsigned char buf[6];
 242   buf[0] = cmd;
 243   buf[1] = arg1;
 244   store_long_parameter (buf + 2, arg2);
 245   return send_data (buf, 6);
 246 }
 247
 248 static int
 249 send_three_arg_cmd (unsigned char cmd, unsigned long arg1, unsigned long arg2,
 250                     unsigned long arg3)
 251 {
 252   unsigned char buf[13];
 253   buf[0] = cmd;
 254   store_long_parameter (buf + 1, arg1);
 255   store_long_parameter (buf + 5, arg2);
 256   store_long_parameter (buf + 9, arg3);
 257   return send_data (buf, 13);
 258 }
 259
 260 static unsigned char
 261 recv_char_data (void)
 262 {
 263   unsigned char val;
 264   recv_data (&val, 1);
 265   return val;
 266 }
 267
 268 static unsigned long
 269 recv_long_data (void)
 270 {
 271   unsigned long val;
 272   recv_data (&val, 4);
 273   return ntohl (val);
 274 }
 275
 276
 277 /* Check if MMU is on */
 278 static void
 279 check_mmu_status (void)
 280 {
 281   unsigned long val;
 282
 283   /* Read PC address */
 284   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC) == -1)
 285     return;
 286   val = recv_long_data ();
 287   if ((val & 0xc0000000) == 0x80000000)
 288     {
 289       mmu_on = 1;
 290       return;
 291     }
 292
 293   /* Read EVB address */
 294   if (send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_EVB) == -1)
 295     return;
 296   val = recv_long_data ();
 297   if ((val & 0xc0000000) == 0x80000000)
 298     {
 299       mmu_on = 1;
 300       return;
 301     }
 302
 303   mmu_on = 0;
 304 }
 305
 306
 307 /* This is called not only when we first attach, but also when the
 308    user types "run" after having attached.  */
 309 static void
 310 m32r_create_inferior (char *execfile, char *args, char **env, int from_tty)
 311 {
 312   CORE_ADDR entry_pt;
 313
 314   if (args && *args)
 315     error (_("Cannot pass arguments to remote STDEBUG process"));
 316
 317   if (execfile == 0 || exec_bfd == 0)
 318     error (_("No executable file specified"));
 319
 320   if (remote_debug)
 321     fprintf_unfiltered (gdb_stdlog, "m32r_create_inferior(%s,%s)\n", execfile,
 322                         args);
 323
 324   entry_pt = bfd_get_start_address (exec_bfd);
 325
 326   /* The "process" (board) is already stopped awaiting our commands, and
 327      the program is already downloaded.  We just set its PC and go.  */
 328
 329   clear_proceed_status ();
 330
 331   /* Tell wait_for_inferior that we've started a new process.  */
 332   init_wait_for_inferior ();
 333
 334   /* Set up the "saved terminal modes" of the inferior
 335      based on what modes we are starting it with.  */
 336   target_terminal_init ();
 337
 338   /* Install inferior's terminal modes.  */
 339   target_terminal_inferior ();
 340
 341   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 342 }
 343
 344 /* Open a connection to a remote debugger.
 345    NAME is the filename used for communication.  */
 346
 347 static void
 348 m32r_open (char *args, int from_tty)
 349 {
 350   struct hostent *host_ent;
 351   struct sockaddr_in server_addr;
 352   char *port_str, hostname[256];
 353   int port;
 354   int i, n;
 355   int yes = 1;
 356
 357   if (remote_debug)
 358     fprintf_unfiltered (gdb_stdlog, "m32r_open(%d)\n", from_tty);
 359
 360   target_preopen (from_tty);
 361
 362   push_target (&m32r_ops);
 363
 364   if (args == NULL)
 365     sprintf (hostname, "localhost:%d", SDIPORT);
 366   else
 367     {
 368       port_str = strchr (args, ':');
 369       if (port_str == NULL)
 370         sprintf (hostname, "%s:%d", args, SDIPORT);
 371       else
 372         strcpy (hostname, args);
 373     }
 374
 375   sdi_desc = serial_open (hostname);
 376   if (!sdi_desc)
 377     error (_("Connection refused."));
 378
 379   if (get_ack () == -1)
 380     error (_("Cannot connect to SDI target."));
 381
 382   if (send_cmd (SDI_OPEN) == -1)
 383     error (_("Cannot connect to SDI target."));
 384
 385   /* Get maximum number of ib breakpoints */
 386   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_BRK);
 387   max_ib_breakpoints = recv_char_data ();
 388   if (remote_debug)
 389     printf_filtered ("Max IB Breakpoints = %d\n", max_ib_breakpoints);
 390
 391   /* Initialize breakpoints. */
 392   for (i = 0; i < MAX_BREAKPOINTS; i++)
 393     bp_address[i] = 0xffffffff;
 394
 395   /* Get maximum number of access breaks. */
 396   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_ABRK);
 397   max_access_breaks = recv_char_data ();
 398   if (remote_debug)
 399     printf_filtered ("Max Access Breaks = %d\n", max_access_breaks);
 400
 401   /* Initialize access breask. */
 402   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
 403     ab_address[i] = 0x00000000;
 404
 405   check_mmu_status ();
 406
 407   /* Get the name of chip on target board. */
 408   send_one_arg_cmd (SDI_GET_ATTR, SDI_ATTR_NAME);
 409   recv_data (chip_name, 64);
 410
 411   if (from_tty)
 412     printf_filtered ("Remote %s connected to %s\n", target_shortname,
 413                      chip_name);
 414 }
 415
 416 /* Close out all files and local state before this target loses control. */
 417
 418 static void
 419 m32r_close (int quitting)
 420 {
 421   if (remote_debug)
 422     fprintf_unfiltered (gdb_stdlog, "m32r_close(%d)\n", quitting);
 423
 424   if (sdi_desc)
 425     {
 426       send_cmd (SDI_CLOSE);
 427       serial_close (sdi_desc);
 428       sdi_desc = NULL;
 429     }
 430
 431   inferior_ptid = null_ptid;
 432   return;
 433 }
 434
 435 /* Tell the remote machine to resume.  */
 436
 437 static void
 438 m32r_resume (ptid_t ptid, int step, enum target_signal sig)
 439 {
 440   unsigned long pc_addr, bp_addr, ab_addr;
 441   int ib_breakpoints;
 442   unsigned char buf[13];
 443   int i;
 444
 445   if (remote_debug)
 446     {
 447       if (step)
 448         fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(step)\n");
 449       else
 450         fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(cont)\n");
 451     }
 452
 453   check_mmu_status ();
 454
 455   pc_addr = read_pc ();
 456   if (remote_debug)
 457     fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
 458
 459   /* At pc address there is a parallel instruction with +2 offset,
 460      so we have to make it a serial instruction or avoid it. */
 461   if (pc_addr == last_pc_addr)
 462     {
 463       /* Avoid a parallel nop. */
 464       if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
 465         {
 466           pc_addr += 2;
 467           /* Now we can forget this instruction. */
 468           last_pc_addr = 0xffffffff;
 469         }
 470       /* Clear a parallel bit. */
 471       else
 472         {
 473           buf[0] = SDI_WRITE_MEMORY;
 474           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 475             store_long_parameter (buf + 1, pc_addr);
 476           else
 477             store_long_parameter (buf + 1, pc_addr - 1);
 478           store_long_parameter (buf + 5, 1);
 479           buf[9] = last_pc_addr_data[0] & 0x7f;
 480           send_data (buf, 10);
 481         }
 482     }
 483
 484   /* Set PC. */
 485   send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 486
 487   /* step mode. */
 488   step_mode = step;
 489   if (step)
 490     {
 491       /* Set PBP. */
 492       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
 493     }
 494   else
 495     {
 496       /* Unset PBP. */
 497       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
 498     }
 499
 500   if (use_ib_breakpoints)
 501     ib_breakpoints = max_ib_breakpoints;
 502   else
 503     ib_breakpoints = 0;
 504
 505   /* Set ib breakpoints. */
 506   for (i = 0; i < ib_breakpoints; i++)
 507     {
 508       bp_addr = bp_address[i];
 509
 510       if (bp_addr == 0xffffffff)
 511         continue;
 512
 513       /* Set PBP. */
 514       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 515         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 516                             0x00000006);
 517       else
 518         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 519                             0x06000000);
 520
 521       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
 522     }
 523
 524   /* Set dbt breakpoints. */
 525   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 526     {
 527       bp_addr = bp_address[i];
 528
 529       if (bp_addr == 0xffffffff)
 530         continue;
 531
 532       if (!mmu_on)
 533         bp_addr &= 0x7fffffff;
 534
 535       /* Write DBT instruction. */
 536       buf[0] = SDI_WRITE_MEMORY;
 537       store_long_parameter (buf + 1, bp_addr);
 538       store_long_parameter (buf + 5, 4);
 539       if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
 540         {
 541           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 542             {
 543               buf[9] = dbt_bp_entry[0];
 544               buf[10] = dbt_bp_entry[1];
 545               buf[11] = dbt_bp_entry[2];
 546               buf[12] = dbt_bp_entry[3];
 547             }
 548           else
 549             {
 550               buf[9] = dbt_bp_entry[3];
 551               buf[10] = dbt_bp_entry[2];
 552               buf[11] = dbt_bp_entry[1];
 553               buf[12] = dbt_bp_entry[0];
 554             }
 555         }
 556       else
 557         {
 558           if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 559             {
 560               if ((bp_addr & 2) == 0)
 561                 {
 562                   buf[9] = dbt_bp_entry[0];
 563                   buf[10] = dbt_bp_entry[1];
 564                   buf[11] = bp_data[i][2] & 0x7f;
 565                   buf[12] = bp_data[i][3];
 566                 }
 567               else
 568                 {
 569                   buf[9] = bp_data[i][0];
 570                   buf[10] = bp_data[i][1];
 571                   buf[11] = dbt_bp_entry[0];
 572                   buf[12] = dbt_bp_entry[1];
 573                 }
 574             }
 575           else
 576             {
 577               if ((bp_addr & 2) == 0)
 578                 {
 579                   buf[9] = bp_data[i][0];
 580                   buf[10] = bp_data[i][1] & 0x7f;
 581                   buf[11] = dbt_bp_entry[1];
 582                   buf[12] = dbt_bp_entry[0];
 583                 }
 584               else
 585                 {
 586                   buf[9] = dbt_bp_entry[1];
 587                   buf[10] = dbt_bp_entry[0];
 588                   buf[11] = bp_data[i][2];
 589                   buf[12] = bp_data[i][3];
 590                 }
 591             }
 592         }
 593       send_data (buf, 13);
 594     }
 595
 596   /* Set access breaks. */
 597   for (i = 0; i < max_access_breaks; i++)
 598     {
 599       ab_addr = ab_address[i];
 600
 601       if (ab_addr == 0x00000000)
 602         continue;
 603
 604       /* DBC register */
 605       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 606         {
 607           switch (ab_type[i])
 608             {
 609             case 0:             /* write watch */
 610               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 611                                   0x00000086);
 612               break;
 613             case 1:             /* read watch */
 614               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 615                                   0x00000046);
 616               break;
 617             case 2:             /* access watch */
 618               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 619                                   0x00000006);
 620               break;
 621             }
 622         }
 623       else
 624         {
 625           switch (ab_type[i])
 626             {
 627             case 0:             /* write watch */
 628               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 629                                   0x86000000);
 630               break;
 631             case 1:             /* read watch */
 632               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 633                                   0x46000000);
 634               break;
 635             case 2:             /* access watch */
 636               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 637                                   0x06000000);
 638               break;
 639             }
 640         }
 641
 642       /* DBAH register */
 643       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
 644
 645       /* DBAL register */
 646       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
 647                           0xffffffff);
 648
 649       /* DBD register */
 650       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
 651                           0x00000000);
 652
 653       /* DBDM register */
 654       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
 655                           0x00000000);
 656     }
 657
 658   /* Resume program. */
 659   send_cmd (SDI_EXEC_CPU);
 660
 661   /* Without this, some commands which require an active target (such as kill)
 662      won't work.  This variable serves (at least) double duty as both the pid
 663      of the target process (if it has such), and as a flag indicating that a
 664      target is active.  These functions should be split out into seperate
 665      variables, especially since GDB will someday have a notion of debugging
 666      several processes.  */
 667   inferior_ptid = pid_to_ptid (32);
 668
 669   return;
 670 }
 671
 672 /* Wait until the remote machine stops, then return,
 673    storing status in STATUS just as `wait' would.  */
 674
 675 static void
 676 gdb_cntrl_c (int signo)
 677 {
 678   if (remote_debug)
 679     fprintf_unfiltered (gdb_stdlog, "interrupt\n");
 680   interrupted = 1;
 681 }
 682
 683 static ptid_t
 684 m32r_wait (ptid_t ptid, struct target_waitstatus *status)
 685 {
 686   static RETSIGTYPE (*prev_sigint) ();
 687   unsigned long bp_addr, pc_addr;
 688   int ib_breakpoints;
 689   long i;
 690   unsigned char buf[13];
 691   unsigned long val;
 692   int ret, c;
 693
 694   if (remote_debug)
 695     fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
 696
 697   status->kind = TARGET_WAITKIND_EXITED;
 698   status->value.sig = 0;
 699
 700   interrupted = 0;
 701   prev_sigint = signal (SIGINT, gdb_cntrl_c);
 702
 703   /* Wait for ready */
 704   buf[0] = SDI_WAIT_FOR_READY;
 705   if (serial_write (sdi_desc, buf, 1) != 0)
 706     error (_("Remote connection closed"));
 707
 708   while (1)
 709     {
 710       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 711       if (c < 0)
 712         error (_("Remote connection closed"));
 713
 714       if (c == '-')             /* error */
 715         {
 716           status->kind = TARGET_WAITKIND_STOPPED;
 717           status->value.sig = TARGET_SIGNAL_HUP;
 718           return inferior_ptid;
 719         }
 720       else if (c == '+')        /* stopped */
 721         break;
 722
 723       if (interrupted)
 724         ret = serial_write (sdi_desc, "!", 1);  /* packet to interrupt */
 725       else
 726         ret = serial_write (sdi_desc, ".", 1);  /* packet to wait */
 727       if (ret != 0)
 728         error (_("Remote connection closed"));
 729     }
 730
 731   status->kind = TARGET_WAITKIND_STOPPED;
 732   if (interrupted)
 733     status->value.sig = TARGET_SIGNAL_INT;
 734   else
 735     status->value.sig = TARGET_SIGNAL_TRAP;
 736
 737   interrupted = 0;
 738   signal (SIGINT, prev_sigint);
 739
 740   check_mmu_status ();
 741
 742   /* Recover parallel bit. */
 743   if (last_pc_addr != 0xffffffff)
 744     {
 745       buf[0] = SDI_WRITE_MEMORY;
 746       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 747         store_long_parameter (buf + 1, last_pc_addr);
 748       else
 749         store_long_parameter (buf + 1, last_pc_addr - 1);
 750       store_long_parameter (buf + 5, 1);
 751       buf[9] = last_pc_addr_data[0];
 752       send_data (buf, 10);
 753       last_pc_addr = 0xffffffff;
 754     }
 755
 756   if (use_ib_breakpoints)
 757     ib_breakpoints = max_ib_breakpoints;
 758   else
 759     ib_breakpoints = 0;
 760
 761   /* Set back pc by 2 if m32r is stopped with dbt. */
 762   last_pc_addr = 0xffffffff;
 763   send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
 764   pc_addr = recv_long_data () - 2;
 765   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 766     {
 767       if (pc_addr == bp_address[i])
 768         {
 769           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 770
 771           /* If there is a parallel instruction with +2 offset at pc
 772              address, we have to take care of it later. */
 773           if ((pc_addr & 0x2) != 0)
 774             {
 775               if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 776                 {
 777                   if ((bp_data[i][2] & 0x80) != 0)
 778                     {
 779                       last_pc_addr = pc_addr;
 780                       last_pc_addr_data[0] = bp_data[i][2];
 781                       last_pc_addr_data[1] = bp_data[i][3];
 782                     }
 783                 }
 784               else
 785                 {
 786                   if ((bp_data[i][1] & 0x80) != 0)
 787                     {
 788                       last_pc_addr = pc_addr;
 789                       last_pc_addr_data[0] = bp_data[i][1];
 790                       last_pc_addr_data[1] = bp_data[i][0];
 791                     }
 792                 }
 793             }
 794           break;
 795         }
 796     }
 797
 798   /* Remove ib breakpoints. */
 799   for (i = 0; i < ib_breakpoints; i++)
 800     {
 801       if (bp_address[i] != 0xffffffff)
 802         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 803                             0x00000000);
 804     }
 805   /* Remove dbt breakpoints. */
 806   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 807     {
 808       bp_addr = bp_address[i];
 809       if (bp_addr != 0xffffffff)
 810         {
 811           if (!mmu_on)
 812             bp_addr &= 0x7fffffff;
 813           buf[0] = SDI_READ_MEMORY;
 814           store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
 815           store_long_parameter (buf + 5, 4);
 816           buf[9] = bp_data[i][0];
 817           buf[10] = bp_data[i][1];
 818           buf[11] = bp_data[i][2];
 819           buf[12] = bp_data[i][3];
 820           send_data (buf, 13);
 821         }
 822     }
 823
 824   /* Remove access breaks. */
 825   hit_watchpoint_addr = 0;
 826   for (i = 0; i < max_access_breaks; i++)
 827     {
 828       if (ab_address[i] != 0x00000000)
 829         {
 830           buf[0] = SDI_READ_MEMORY;
 831           store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
 832           store_long_parameter (buf + 5, 4);
 833           serial_write (sdi_desc, buf, 9);
 834           c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 835           if (c != '-' && recv_data (buf, 4) != -1)
 836             {
 837               if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 838                 {
 839                   if ((buf[3] & 0x1) == 0x1)
 840                     hit_watchpoint_addr = ab_address[i];
 841                 }
 842               else
 843                 {
 844                   if ((buf[0] & 0x1) == 0x1)
 845                     hit_watchpoint_addr = ab_address[i];
 846                 }
 847             }
 848
 849           send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 850                               0x00000000);
 851         }
 852     }
 853
 854   if (remote_debug)
 855     fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
 856
 857   return inferior_ptid;
 858 }
 859
 860 /* Terminate the open connection to the remote debugger.
 861    Use this when you want to detach and do something else
 862    with your gdb.  */
 863 static void
 864 m32r_detach (char *args, int from_tty)
 865 {
 866   if (remote_debug)
 867     fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
 868
 869   m32r_resume (inferior_ptid, 0, 0);
 870
 871   /* calls m32r_close to do the real work */
 872   pop_target ();
 873   if (from_tty)
 874     fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
 875                         target_shortname);
 876 }
 877
 878 /* Return the id of register number REGNO. */
 879
 880 static int
 881 get_reg_id (int regno)
 882 {
 883   switch (regno)
 884     {
 885     case 20:
 886       return SDI_REG_BBPC;
 887     case 21:
 888       return SDI_REG_BPC;
 889     case 22:
 890       return SDI_REG_ACCL;
 891     case 23:
 892       return SDI_REG_ACCH;
 893     case 24:
 894       return SDI_REG_EVB;
 895     }
 896
 897   return regno;
 898 }
 899
 900 /* Read the remote registers into the block REGS.  */
 901
 902 static void m32r_fetch_register (int);
 903
 904 static void
 905 m32r_fetch_registers (void)
 906 {
 907   int regno;
 908
 909   for (regno = 0; regno < NUM_REGS; regno++)
 910     m32r_fetch_register (regno);
 911 }
 912
 913 /* Fetch register REGNO, or all registers if REGNO is -1.
 914    Returns errno value.  */
 915 static void
 916 m32r_fetch_register (int regno)
 917 {
 918   unsigned long val, val2, regid;
 919
 920   if (regno == -1)
 921     m32r_fetch_registers ();
 922   else
 923     {
 924       char buffer[MAX_REGISTER_SIZE];
 925
 926       regid = get_reg_id (regno);
 927       send_one_arg_cmd (SDI_READ_CPU_REG, regid);
 928       val = recv_long_data ();
 929
 930       if (regid == SDI_REG_PSW)
 931         {
 932           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
 933           val2 = recv_long_data ();
 934           val = ((0x00c1 & val2) << 8) | ((0xc100 & val) >> 8);
 935         }
 936
 937       if (remote_debug)
 938         fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
 939                             regno, val);
 940
 941       /* We got the number the register holds, but gdb expects to see a
 942          value in the target byte ordering.  */
 943       store_unsigned_integer (buffer, 4, val);
 944       regcache_raw_supply (current_regcache, regno, buffer);
 945     }
 946   return;
 947 }
 948
 949 /* Store the remote registers from the contents of the block REGS.  */
 950
 951 static void m32r_store_register (int);
 952
 953 static void
 954 m32r_store_registers (void)
 955 {
 956   int regno;
 957
 958   for (regno = 0; regno < NUM_REGS; regno++)
 959     m32r_store_register (regno);
 960
 961   registers_changed ();
 962 }
 963
 964 /* Store register REGNO, or all if REGNO == 0.
 965    Return errno value.  */
 966 static void
 967 m32r_store_register (int regno)
 968 {
 969   int regid;
 970   ULONGEST regval, tmp;
 971
 972   if (regno == -1)
 973     m32r_store_registers ();
 974   else
 975     {
 976       regcache_cooked_read_unsigned (current_regcache, regno, &regval);
 977       regid = get_reg_id (regno);
 978
 979       if (regid == SDI_REG_PSW)
 980         {
 981           unsigned long psw, bbpsw;
 982
 983           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
 984           psw = recv_long_data ();
 985
 986           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
 987           bbpsw = recv_long_data ();
 988
 989           tmp = (0x00c1 & psw) | ((0x00c1 & regval) << 8);
 990           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
 991
 992           tmp = (0x0030 & bbpsw) | ((0xc100 & regval) >> 8);
 993           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
 994         }
 995       else
 996         {
 997           send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
 998         }
 999
1000       if (remote_debug)
1001         fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1002                             regno, (unsigned long) regval);
1003     }
1004 }
1005
1006 /* Get ready to modify the registers array.  On machines which store
1007    individual registers, this doesn't need to do anything.  On machines
1008    which store all the registers in one fell swoop, this makes sure
1009    that registers contains all the registers from the program being
1010    debugged.  */
1011
1012 static void
1013 m32r_prepare_to_store (void)
1014 {
1015   /* Do nothing, since we can store individual regs */
1016   if (remote_debug)
1017     fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1018 }
1019
1020 static void
1021 m32r_files_info (struct target_ops *target)
1022 {
1023   char *file = "nothing";
1024
1025   if (exec_bfd)
1026     {
1027       file = bfd_get_filename (exec_bfd);
1028       printf_filtered ("\tAttached to %s running program %s\n",
1029                        chip_name, file);
1030     }
1031 }
1032
1033 /* Read/Write memory.  */
1034 static int
1035 m32r_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
1036                   int write,
1037                   struct mem_attrib *attrib, struct target_ops *target)
1038 {
1039   unsigned long taddr;
1040   unsigned char buf[0x2000];
1041   int ret, c;
1042
1043   taddr = memaddr;
1044
1045   if (!mmu_on)
1046     {
1047       if ((taddr & 0xa0000000) == 0x80000000)
1048         taddr &= 0x7fffffff;
1049     }
1050
1051   if (remote_debug)
1052     {
1053       if (write)
1054         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,write)\n",
1055                             memaddr, len);
1056       else
1057         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%08lx,%d,read)\n",
1058                             memaddr, len);
1059     }
1060
1061   if (write)
1062     {
1063       buf[0] = SDI_WRITE_MEMORY;
1064       store_long_parameter (buf + 1, taddr);
1065       store_long_parameter (buf + 5, len);
1066       if (len < 0x1000)
1067         {
1068           memcpy (buf + 9, myaddr, len);
1069           ret = send_data (buf, len + 9) - 9;
1070         }
1071       else
1072         {
1073           if (serial_write (sdi_desc, buf, 9) != 0)
1074             {
1075               if (remote_debug)
1076                 fprintf_unfiltered (gdb_stdlog,
1077                                     "m32r_xfer_memory() failed\n");
1078               return 0;
1079             }
1080           ret = send_data (myaddr, len);
1081         }
1082     }
1083   else
1084     {
1085       buf[0] = SDI_READ_MEMORY;
1086       store_long_parameter (buf + 1, taddr);
1087       store_long_parameter (buf + 5, len);
1088       if (serial_write (sdi_desc, buf, 9) != 0)
1089         {
1090           if (remote_debug)
1091             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1092           return 0;
1093         }
1094
1095       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1096       if (c < 0 || c == '-')
1097         {
1098           if (remote_debug)
1099             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1100           return 0;
1101         }
1102
1103       ret = recv_data (myaddr, len);
1104     }
1105
1106   if (ret <= 0)
1107     {
1108       if (remote_debug)
1109         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1110       return 0;
1111     }
1112
1113   return ret;
1114 }
1115
1116 static void
1117 m32r_kill (void)
1118 {
1119   if (remote_debug)
1120     fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1121
1122   inferior_ptid = null_ptid;
1123
1124   return;
1125 }
1126
1127 /* Clean up when a program exits.
1128
1129    The program actually lives on in the remote processor's RAM, and may be
1130    run again without a download.  Don't leave it full of breakpoint
1131    instructions.  */
1132
1133 static void
1134 m32r_mourn_inferior (void)
1135 {
1136   if (remote_debug)
1137     fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1138
1139   remove_breakpoints ();
1140   generic_mourn_inferior ();
1141 }
1142
1143 static int
1144 m32r_insert_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
1145 {
1146   int ib_breakpoints;
1147   unsigned char buf[13];
1148   int i, c;
1149
1150   if (remote_debug)
1151     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%08lx,\"%s\")\n",
1152                         addr, shadow);
1153
1154   if (use_ib_breakpoints)
1155     ib_breakpoints = max_ib_breakpoints;
1156   else
1157     ib_breakpoints = 0;
1158
1159   for (i = 0; i < MAX_BREAKPOINTS; i++)
1160     {
1161       if (bp_address[i] == 0xffffffff)
1162         {
1163           bp_address[i] = addr;
1164           if (i >= ib_breakpoints)
1165             {
1166               buf[0] = SDI_READ_MEMORY;
1167               if (mmu_on)
1168                 store_long_parameter (buf + 1, addr & 0xfffffffc);
1169               else
1170                 store_long_parameter (buf + 1, addr & 0x7ffffffc);
1171               store_long_parameter (buf + 5, 4);
1172               serial_write (sdi_desc, buf, 9);
1173               c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1174               if (c != '-')
1175                 recv_data (bp_data[i], 4);
1176             }
1177           return 0;
1178         }
1179     }
1180
1181   error (_("Too many breakpoints"));
1182   return 1;
1183 }
1184
1185 static int
1186 m32r_remove_breakpoint (CORE_ADDR addr, bfd_byte *shadow)
1187 {
1188   int i;
1189
1190   if (remote_debug)
1191     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%08lx,\"%s\")\n",
1192                         addr, shadow);
1193
1194   for (i = 0; i < MAX_BREAKPOINTS; i++)
1195     {
1196       if (bp_address[i] == addr)
1197         {
1198           bp_address[i] = 0xffffffff;
1199           break;
1200         }
1201     }
1202
1203   return 0;
1204 }
1205
1206 static void
1207 m32r_load (char *args, int from_tty)
1208 {
1209   struct cleanup *old_chain;
1210   asection *section;
1211   bfd *pbfd;
1212   bfd_vma entry;
1213   char *filename;
1214   int quiet;
1215   int nostart;
1216   time_t start_time, end_time;  /* Start and end times of download */
1217   unsigned long data_count;     /* Number of bytes transferred to memory */
1218   int ret;
1219   static RETSIGTYPE (*prev_sigint) ();
1220
1221   /* for direct tcp connections, we can do a fast binary download */
1222   quiet = 0;
1223   nostart = 0;
1224   filename = NULL;
1225
1226   while (*args != '\000')
1227     {
1228       char *arg;
1229
1230       while (isspace (*args))
1231         args++;
1232
1233       arg = args;
1234
1235       while ((*args != '\000') && !isspace (*args))
1236         args++;
1237
1238       if (*args != '\000')
1239         *args++ = '\000';
1240
1241       if (*arg != '-')
1242         filename = arg;
1243       else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1244         quiet = 1;
1245       else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1246         nostart = 1;
1247       else
1248         error (_("Unknown option `%s'"), arg);
1249     }
1250
1251   if (!filename)
1252     filename = get_exec_file (1);
1253
1254   pbfd = bfd_openr (filename, gnutarget);
1255   if (pbfd == NULL)
1256     {
1257       perror_with_name (filename);
1258       return;
1259     }
1260   old_chain = make_cleanup_bfd_close (pbfd);
1261
1262   if (!bfd_check_format (pbfd, bfd_object))
1263     error (_("\"%s\" is not an object file: %s"), filename,
1264            bfd_errmsg (bfd_get_error ()));
1265
1266   start_time = time (NULL);
1267   data_count = 0;
1268
1269   interrupted = 0;
1270   prev_sigint = signal (SIGINT, gdb_cntrl_c);
1271
1272   for (section = pbfd->sections; section; section = section->next)
1273     {
1274       if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1275         {
1276           bfd_vma section_address;
1277           bfd_size_type section_size;
1278           file_ptr fptr;
1279           int n;
1280
1281           section_address = bfd_section_lma (pbfd, section);
1282           section_size = bfd_get_section_size (section);
1283
1284           if (!mmu_on)
1285             {
1286               if ((section_address & 0xa0000000) == 0x80000000)
1287                 section_address &= 0x7fffffff;
1288             }
1289
1290           if (!quiet)
1291             printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1292                              bfd_get_section_name (pbfd, section),
1293                              section_address, (int) section_size);
1294
1295           fptr = 0;
1296
1297           data_count += section_size;
1298
1299           n = 0;
1300           while (section_size > 0)
1301             {
1302               char unsigned buf[0x1000 + 9];
1303               int count;
1304
1305               count = min (section_size, 0x1000);
1306
1307               buf[0] = SDI_WRITE_MEMORY;
1308               store_long_parameter (buf + 1, section_address);
1309               store_long_parameter (buf + 5, count);
1310
1311               bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1312               if (send_data (buf, count + 9) <= 0)
1313                 error (_("Error while downloading %s section."),
1314                        bfd_get_section_name (pbfd, section));
1315
1316               if (!quiet)
1317                 {
1318                   printf_unfiltered (".");
1319                   if (n++ > 60)
1320                     {
1321                       printf_unfiltered ("\n");
1322                       n = 0;
1323                     }
1324                   gdb_flush (gdb_stdout);
1325                 }
1326
1327               section_address += count;
1328               fptr += count;
1329               section_size -= count;
1330
1331               if (interrupted)
1332                 break;
1333             }
1334
1335           if (!quiet && !interrupted)
1336             {
1337               printf_unfiltered ("done.\n");
1338               gdb_flush (gdb_stdout);
1339             }
1340         }
1341
1342       if (interrupted)
1343         {
1344           printf_unfiltered ("Interrupted.\n");
1345           break;
1346         }
1347     }
1348
1349   interrupted = 0;
1350   signal (SIGINT, prev_sigint);
1351
1352   end_time = time (NULL);
1353
1354   /* Make the PC point at the start address */
1355   if (exec_bfd)
1356     write_pc (bfd_get_start_address (exec_bfd));
1357
1358   inferior_ptid = null_ptid;    /* No process now */
1359
1360   /* This is necessary because many things were based on the PC at the time
1361      that we attached to the monitor, which is no longer valid now that we
1362      have loaded new code (and just changed the PC).  Another way to do this
1363      might be to call normal_stop, except that the stack may not be valid,
1364      and things would get horribly confused... */
1365
1366   clear_symtab_users ();
1367
1368   if (!nostart)
1369     {
1370       entry = bfd_get_start_address (pbfd);
1371
1372       if (!quiet)
1373         printf_unfiltered ("[Starting %s at 0x%lx]\n", filename, entry);
1374     }
1375
1376   print_transfer_performance (gdb_stdout, data_count, 0,
1377                               end_time - start_time);
1378
1379   do_cleanups (old_chain);
1380 }
1381
1382 static void
1383 m32r_stop (void)
1384 {
1385   if (remote_debug)
1386     fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1387
1388   send_cmd (SDI_STOP_CPU);
1389
1390   return;
1391 }
1392
1393
1394 /* Tell whether this target can support a hardware breakpoint.  CNT
1395    is the number of hardware breakpoints already installed.  This
1396    implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
1397
1398 int
1399 m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
1400 {
1401   return sdi_desc != NULL && cnt < max_access_breaks;
1402 }
1403
1404 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
1405    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1406    watchpoint. */
1407
1408 int
1409 m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
1410 {
1411   int i;
1412
1413   if (remote_debug)
1414     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%08lx,%d,%d)\n",
1415                         addr, len, type);
1416
1417   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1418     {
1419       if (ab_address[i] == 0x00000000)
1420         {
1421           ab_address[i] = addr;
1422           ab_size[i] = len;
1423           ab_type[i] = type;
1424           return 0;
1425         }
1426     }
1427
1428   error (_("Too many watchpoints"));
1429   return 1;
1430 }
1431
1432 int
1433 m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1434 {
1435   int i;
1436
1437   if (remote_debug)
1438     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%08lx,%d,%d)\n",
1439                         addr, len, type);
1440
1441   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1442     {
1443       if (ab_address[i] == addr)
1444         {
1445           ab_address[i] = 0x00000000;
1446           break;
1447         }
1448     }
1449
1450   return 0;
1451 }
1452
1453 int
1454 m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1455 {
1456   int rc = 0;
1457   if (hit_watchpoint_addr != 0x00000000)
1458     {
1459       *addr_p = hit_watchpoint_addr;
1460       rc = 1;
1461     }
1462   return rc;
1463 }
1464
1465 int
1466 m32r_stopped_by_watchpoint (void)
1467 {
1468   CORE_ADDR addr;
1469   return m32r_stopped_data_address (&current_target, &addr);
1470 }
1471
1472
1473 static void
1474 sdireset_command (char *args, int from_tty)
1475 {
1476   if (remote_debug)
1477     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1478
1479   send_cmd (SDI_OPEN);
1480
1481   inferior_ptid = null_ptid;
1482 }
1483
1484
1485 static void
1486 sdistatus_command (char *args, int from_tty)
1487 {
1488   unsigned char buf[4096];
1489   int i, c;
1490
1491   if (remote_debug)
1492     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1493
1494   if (!sdi_desc)
1495     return;
1496
1497   send_cmd (SDI_STATUS);
1498   for (i = 0; i < 4096; i++)
1499     {
1500       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1501       if (c < 0)
1502         return;
1503       buf[i] = c;
1504       if (c == 0)
1505         break;
1506     }
1507
1508   printf_filtered ("%s", buf);
1509 }
1510
1511
1512 static void
1513 debug_chaos_command (char *args, int from_tty)
1514 {
1515   unsigned char buf[3];
1516
1517   buf[0] = SDI_SET_ATTR;
1518   buf[1] = SDI_ATTR_CACHE;
1519   buf[2] = SDI_CACHE_TYPE_CHAOS;
1520   send_data (buf, 3);
1521 }
1522
1523
1524 static void
1525 use_debug_dma_command (char *args, int from_tty)
1526 {
1527   unsigned char buf[3];
1528
1529   buf[0] = SDI_SET_ATTR;
1530   buf[1] = SDI_ATTR_MEM_ACCESS;
1531   buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1532   send_data (buf, 3);
1533 }
1534
1535 static void
1536 use_mon_code_command (char *args, int from_tty)
1537 {
1538   unsigned char buf[3];
1539
1540   buf[0] = SDI_SET_ATTR;
1541   buf[1] = SDI_ATTR_MEM_ACCESS;
1542   buf[2] = SDI_MEM_ACCESS_MON_CODE;
1543   send_data (buf, 3);
1544 }
1545
1546
1547 static void
1548 use_ib_breakpoints_command (char *args, int from_tty)
1549 {
1550   use_ib_breakpoints = 1;
1551 }
1552
1553 static void
1554 use_dbt_breakpoints_command (char *args, int from_tty)
1555 {
1556   use_ib_breakpoints = 0;
1557 }
1558
1559
1560 /* Define the target subroutine names */
1561
1562 struct target_ops m32r_ops;
1563
1564 static void
1565 init_m32r_ops (void)
1566 {
1567   m32r_ops.to_shortname = "m32rsdi";
1568   m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1569   m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1570   m32r_ops.to_open = m32r_open;
1571   m32r_ops.to_close = m32r_close;
1572   m32r_ops.to_detach = m32r_detach;
1573   m32r_ops.to_resume = m32r_resume;
1574   m32r_ops.to_wait = m32r_wait;
1575   m32r_ops.to_fetch_registers = m32r_fetch_register;
1576   m32r_ops.to_store_registers = m32r_store_register;
1577   m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
1578   m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
1579   m32r_ops.to_files_info = m32r_files_info;
1580   m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1581   m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
1582   m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1583   m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1584   m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1585   m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1586   m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
1587   m32r_ops.to_kill = m32r_kill;
1588   m32r_ops.to_load = m32r_load;
1589   m32r_ops.to_create_inferior = m32r_create_inferior;
1590   m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1591   m32r_ops.to_stop = m32r_stop;
1592   m32r_ops.to_stratum = process_stratum;
1593   m32r_ops.to_has_all_memory = 1;
1594   m32r_ops.to_has_memory = 1;
1595   m32r_ops.to_has_stack = 1;
1596   m32r_ops.to_has_registers = 1;
1597   m32r_ops.to_has_execution = 1;
1598   m32r_ops.to_magic = OPS_MAGIC;
1599 };
1600
1601
1602 extern initialize_file_ftype _initialize_remote_m32r;
1603
1604 void
1605 _initialize_remote_m32r (void)
1606 {
1607   int i;
1608
1609   init_m32r_ops ();
1610
1611   /* Initialize breakpoints. */
1612   for (i = 0; i < MAX_BREAKPOINTS; i++)
1613     bp_address[i] = 0xffffffff;
1614
1615   /* Initialize access breaks. */
1616   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1617     ab_address[i] = 0x00000000;
1618
1619   add_target (&m32r_ops);
1620
1621   add_com ("sdireset", class_obscure, sdireset_command,
1622            _("Reset SDI connection."));
1623
1624   add_com ("sdistatus", class_obscure, sdistatus_command,
1625            _("Show status of SDI connection."));
1626
1627   add_com ("debug_chaos", class_obscure, debug_chaos_command,
1628            _("Debug M32R/Chaos."));
1629
1630   add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1631            _("Use debug DMA mem access."));
1632   add_com ("use_mon_code", class_obscure, use_mon_code_command,
1633            _("Use mon code mem access."));
1634
1635   add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1636            _("Set breakpoints by IB break."));
1637   add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1638            _("Set breakpoints by dbt."));
1639 }