gdb/remote-m32r-sdi.c

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