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;
 912        regno < gdbarch_num_regs (get_regcache_arch (regcache));
 913        regno++)
 914     m32r_fetch_register (regcache, regno);
 915 }
 916
 917 /* Fetch register REGNO, or all registers if REGNO is -1.
 918    Returns errno value.  */
 919 static void
 920 m32r_fetch_register (struct regcache *regcache, int regno)
 921 {
 922   unsigned long val, val2, regid;
 923
 924   if (regno == -1)
 925     m32r_fetch_registers (regcache);
 926   else
 927     {
 928       char buffer[MAX_REGISTER_SIZE];
 929
 930       regid = get_reg_id (regno);
 931       send_one_arg_cmd (SDI_READ_CPU_REG, regid);
 932       val = recv_long_data ();
 933
 934       if (regid == SDI_REG_PSW)
 935         {
 936           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
 937           val2 = recv_long_data ();
 938           val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
 939         }
 940
 941       if (remote_debug)
 942         fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
 943                             regno, val);
 944
 945       /* We got the number the register holds, but gdb expects to see a
 946          value in the target byte ordering.  */
 947       store_unsigned_integer (buffer, 4, val);
 948       regcache_raw_supply (regcache, regno, buffer);
 949     }
 950   return;
 951 }
 952
 953 /* Store the remote registers from the contents of the block REGS.  */
 954
 955 static void m32r_store_register (struct regcache *, int);
 956
 957 static void
 958 m32r_store_registers (struct regcache *regcache)
 959 {
 960   int regno;
 961
 962   for (regno = 0;
 963        regno < gdbarch_num_regs (get_regcache_arch (regcache));
 964        regno++)
 965     m32r_store_register (regcache, regno);
 966
 967   registers_changed ();
 968 }
 969
 970 /* Store register REGNO, or all if REGNO == 0.
 971    Return errno value.  */
 972 static void
 973 m32r_store_register (struct regcache *regcache, int regno)
 974 {
 975   int regid;
 976   ULONGEST regval, tmp;
 977
 978   if (regno == -1)
 979     m32r_store_registers (regcache);
 980   else
 981     {
 982       regcache_cooked_read_unsigned (regcache, regno, &regval);
 983       regid = get_reg_id (regno);
 984
 985       if (regid == SDI_REG_PSW)
 986         {
 987           unsigned long psw, bbpsw;
 988
 989           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
 990           psw = recv_long_data ();
 991
 992           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
 993           bbpsw = recv_long_data ();
 994
 995           tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
 996           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
 997
 998           tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
 999           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
1000         }
1001       else
1002         {
1003           send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
1004         }
1005
1006       if (remote_debug)
1007         fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1008                             regno, (unsigned long) regval);
1009     }
1010 }
1011
1012 /* Get ready to modify the registers array.  On machines which store
1013    individual registers, this doesn't need to do anything.  On machines
1014    which store all the registers in one fell swoop, this makes sure
1015    that registers contains all the registers from the program being
1016    debugged.  */
1017
1018 static void
1019 m32r_prepare_to_store (struct regcache *regcache)
1020 {
1021   /* Do nothing, since we can store individual regs */
1022   if (remote_debug)
1023     fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1024 }
1025
1026 static void
1027 m32r_files_info (struct target_ops *target)
1028 {
1029   char *file = "nothing";
1030
1031   if (exec_bfd)
1032     {
1033       file = bfd_get_filename (exec_bfd);
1034       printf_filtered ("\tAttached to %s running program %s\n",
1035                        chip_name, file);
1036     }
1037 }
1038
1039 /* Read/Write memory.  */
1040 static int
1041 m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1042                   int write,
1043                   struct mem_attrib *attrib, struct target_ops *target)
1044 {
1045   unsigned long taddr;
1046   unsigned char buf[0x2000];
1047   int ret, c;
1048
1049   taddr = memaddr;
1050
1051   if (!mmu_on)
1052     {
1053       if ((taddr & 0xa0000000) == 0x80000000)
1054         taddr &= 0x7fffffff;
1055     }
1056
1057   if (remote_debug)
1058     {
1059       if (write)
1060         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
1061                             paddr (memaddr), len);
1062       else
1063         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
1064                             paddr (memaddr), len);
1065     }
1066
1067   if (write)
1068     {
1069       buf[0] = SDI_WRITE_MEMORY;
1070       store_long_parameter (buf + 1, taddr);
1071       store_long_parameter (buf + 5, len);
1072       if (len < 0x1000)
1073         {
1074           memcpy (buf + 9, myaddr, len);
1075           ret = send_data (buf, len + 9) - 9;
1076         }
1077       else
1078         {
1079           if (serial_write (sdi_desc, buf, 9) != 0)
1080             {
1081               if (remote_debug)
1082                 fprintf_unfiltered (gdb_stdlog,
1083                                     "m32r_xfer_memory() failed\n");
1084               return 0;
1085             }
1086           ret = send_data (myaddr, len);
1087         }
1088     }
1089   else
1090     {
1091       buf[0] = SDI_READ_MEMORY;
1092       store_long_parameter (buf + 1, taddr);
1093       store_long_parameter (buf + 5, len);
1094       if (serial_write (sdi_desc, buf, 9) != 0)
1095         {
1096           if (remote_debug)
1097             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1098           return 0;
1099         }
1100
1101       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1102       if (c < 0 || c == '-')
1103         {
1104           if (remote_debug)
1105             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1106           return 0;
1107         }
1108
1109       ret = recv_data (myaddr, len);
1110     }
1111
1112   if (ret <= 0)
1113     {
1114       if (remote_debug)
1115         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1116       return 0;
1117     }
1118
1119   return ret;
1120 }
1121
1122 static void
1123 m32r_kill (void)
1124 {
1125   if (remote_debug)
1126     fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1127
1128   inferior_ptid = null_ptid;
1129
1130   return;
1131 }
1132
1133 /* Clean up when a program exits.
1134
1135    The program actually lives on in the remote processor's RAM, and may be
1136    run again without a download.  Don't leave it full of breakpoint
1137    instructions.  */
1138
1139 static void
1140 m32r_mourn_inferior (void)
1141 {
1142   if (remote_debug)
1143     fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1144
1145   remove_breakpoints ();
1146   generic_mourn_inferior ();
1147 }
1148
1149 static int
1150 m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
1151 {
1152   CORE_ADDR addr = bp_tgt->placed_address;
1153   int ib_breakpoints;
1154   unsigned char buf[13];
1155   int i, c;
1156
1157   if (remote_debug)
1158     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
1159                         paddr (addr));
1160
1161   if (use_ib_breakpoints)
1162     ib_breakpoints = max_ib_breakpoints;
1163   else
1164     ib_breakpoints = 0;
1165
1166   for (i = 0; i < MAX_BREAKPOINTS; i++)
1167     {
1168       if (bp_address[i] == 0xffffffff)
1169         {
1170           bp_address[i] = addr;
1171           if (i >= ib_breakpoints)
1172             {
1173               buf[0] = SDI_READ_MEMORY;
1174               if (mmu_on)
1175                 store_long_parameter (buf + 1, addr & 0xfffffffc);
1176               else
1177                 store_long_parameter (buf + 1, addr & 0x7ffffffc);
1178               store_long_parameter (buf + 5, 4);
1179               serial_write (sdi_desc, buf, 9);
1180               c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1181               if (c != '-')
1182                 recv_data (bp_data[i], 4);
1183             }
1184           return 0;
1185         }
1186     }
1187
1188   error (_("Too many breakpoints"));
1189   return 1;
1190 }
1191
1192 static int
1193 m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
1194 {
1195   CORE_ADDR addr = bp_tgt->placed_address;
1196   int i;
1197
1198   if (remote_debug)
1199     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
1200                         paddr (addr));
1201
1202   for (i = 0; i < MAX_BREAKPOINTS; i++)
1203     {
1204       if (bp_address[i] == addr)
1205         {
1206           bp_address[i] = 0xffffffff;
1207           break;
1208         }
1209     }
1210
1211   return 0;
1212 }
1213
1214 static void
1215 m32r_load (char *args, int from_tty)
1216 {
1217   struct cleanup *old_chain;
1218   asection *section;
1219   bfd *pbfd;
1220   bfd_vma entry;
1221   char *filename;
1222   int quiet;
1223   int nostart;
1224   struct timeval start_time, end_time;
1225   unsigned long data_count;     /* Number of bytes transferred to memory */
1226   int ret;
1227   static RETSIGTYPE (*prev_sigint) ();
1228
1229   /* for direct tcp connections, we can do a fast binary download */
1230   quiet = 0;
1231   nostart = 0;
1232   filename = NULL;
1233
1234   while (*args != '\000')
1235     {
1236       char *arg;
1237
1238       while (isspace (*args))
1239         args++;
1240
1241       arg = args;
1242
1243       while ((*args != '\000') && !isspace (*args))
1244         args++;
1245
1246       if (*args != '\000')
1247         *args++ = '\000';
1248
1249       if (*arg != '-')
1250         filename = arg;
1251       else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1252         quiet = 1;
1253       else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1254         nostart = 1;
1255       else
1256         error (_("Unknown option `%s'"), arg);
1257     }
1258
1259   if (!filename)
1260     filename = get_exec_file (1);
1261
1262   pbfd = bfd_openr (filename, gnutarget);
1263   if (pbfd == NULL)
1264     {
1265       perror_with_name (filename);
1266       return;
1267     }
1268   old_chain = make_cleanup_bfd_close (pbfd);
1269
1270   if (!bfd_check_format (pbfd, bfd_object))
1271     error (_("\"%s\" is not an object file: %s"), filename,
1272            bfd_errmsg (bfd_get_error ()));
1273
1274   gettimeofday (&start_time, NULL);
1275   data_count = 0;
1276
1277   interrupted = 0;
1278   prev_sigint = signal (SIGINT, gdb_cntrl_c);
1279
1280   for (section = pbfd->sections; section; section = section->next)
1281     {
1282       if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1283         {
1284           bfd_vma section_address;
1285           bfd_size_type section_size;
1286           file_ptr fptr;
1287           int n;
1288
1289           section_address = bfd_section_lma (pbfd, section);
1290           section_size = bfd_get_section_size (section);
1291
1292           if (!mmu_on)
1293             {
1294               if ((section_address & 0xa0000000) == 0x80000000)
1295                 section_address &= 0x7fffffff;
1296             }
1297
1298           if (!quiet)
1299             printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1300                              bfd_get_section_name (pbfd, section),
1301                              (unsigned long) section_address,
1302                              (int) section_size);
1303
1304           fptr = 0;
1305
1306           data_count += section_size;
1307
1308           n = 0;
1309           while (section_size > 0)
1310             {
1311               char unsigned buf[0x1000 + 9];
1312               int count;
1313
1314               count = min (section_size, 0x1000);
1315
1316               buf[0] = SDI_WRITE_MEMORY;
1317               store_long_parameter (buf + 1, section_address);
1318               store_long_parameter (buf + 5, count);
1319
1320               bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1321               if (send_data (buf, count + 9) <= 0)
1322                 error (_("Error while downloading %s section."),
1323                        bfd_get_section_name (pbfd, section));
1324
1325               if (!quiet)
1326                 {
1327                   printf_unfiltered (".");
1328                   if (n++ > 60)
1329                     {
1330                       printf_unfiltered ("\n");
1331                       n = 0;
1332                     }
1333                   gdb_flush (gdb_stdout);
1334                 }
1335
1336               section_address += count;
1337               fptr += count;
1338               section_size -= count;
1339
1340               if (interrupted)
1341                 break;
1342             }
1343
1344           if (!quiet && !interrupted)
1345             {
1346               printf_unfiltered ("done.\n");
1347               gdb_flush (gdb_stdout);
1348             }
1349         }
1350
1351       if (interrupted)
1352         {
1353           printf_unfiltered ("Interrupted.\n");
1354           break;
1355         }
1356     }
1357
1358   interrupted = 0;
1359   signal (SIGINT, prev_sigint);
1360
1361   gettimeofday (&end_time, NULL);
1362
1363   /* Make the PC point at the start address */
1364   if (exec_bfd)
1365     write_pc (bfd_get_start_address (exec_bfd));
1366
1367   inferior_ptid = null_ptid;    /* No process now */
1368
1369   /* This is necessary because many things were based on the PC at the time
1370      that we attached to the monitor, which is no longer valid now that we
1371      have loaded new code (and just changed the PC).  Another way to do this
1372      might be to call normal_stop, except that the stack may not be valid,
1373      and things would get horribly confused... */
1374
1375   clear_symtab_users ();
1376
1377   if (!nostart)
1378     {
1379       entry = bfd_get_start_address (pbfd);
1380
1381       if (!quiet)
1382         printf_unfiltered ("[Starting %s at 0x%lx]\n", filename,
1383                            (unsigned long) entry);
1384     }
1385
1386   print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
1387                               &end_time);
1388
1389   do_cleanups (old_chain);
1390 }
1391
1392 static void
1393 m32r_stop (void)
1394 {
1395   if (remote_debug)
1396     fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1397
1398   send_cmd (SDI_STOP_CPU);
1399
1400   return;
1401 }
1402
1403
1404 /* Tell whether this target can support a hardware breakpoint.  CNT
1405    is the number of hardware breakpoints already installed.  This
1406    implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
1407
1408 int
1409 m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
1410 {
1411   return sdi_desc != NULL && cnt < max_access_breaks;
1412 }
1413
1414 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
1415    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1416    watchpoint. */
1417
1418 int
1419 m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
1420 {
1421   int i;
1422
1423   if (remote_debug)
1424     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
1425                         paddr (addr), len, type);
1426
1427   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1428     {
1429       if (ab_address[i] == 0x00000000)
1430         {
1431           ab_address[i] = addr;
1432           ab_size[i] = len;
1433           ab_type[i] = type;
1434           return 0;
1435         }
1436     }
1437
1438   error (_("Too many watchpoints"));
1439   return 1;
1440 }
1441
1442 int
1443 m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1444 {
1445   int i;
1446
1447   if (remote_debug)
1448     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
1449                         paddr (addr), len, type);
1450
1451   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1452     {
1453       if (ab_address[i] == addr)
1454         {
1455           ab_address[i] = 0x00000000;
1456           break;
1457         }
1458     }
1459
1460   return 0;
1461 }
1462
1463 int
1464 m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1465 {
1466   int rc = 0;
1467   if (hit_watchpoint_addr != 0x00000000)
1468     {
1469       *addr_p = hit_watchpoint_addr;
1470       rc = 1;
1471     }
1472   return rc;
1473 }
1474
1475 int
1476 m32r_stopped_by_watchpoint (void)
1477 {
1478   CORE_ADDR addr;
1479   return m32r_stopped_data_address (&current_target, &addr);
1480 }
1481
1482
1483 static void
1484 sdireset_command (char *args, int from_tty)
1485 {
1486   if (remote_debug)
1487     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1488
1489   send_cmd (SDI_OPEN);
1490
1491   inferior_ptid = null_ptid;
1492 }
1493
1494
1495 static void
1496 sdistatus_command (char *args, int from_tty)
1497 {
1498   unsigned char buf[4096];
1499   int i, c;
1500
1501   if (remote_debug)
1502     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1503
1504   if (!sdi_desc)
1505     return;
1506
1507   send_cmd (SDI_STATUS);
1508   for (i = 0; i < 4096; i++)
1509     {
1510       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1511       if (c < 0)
1512         return;
1513       buf[i] = c;
1514       if (c == 0)
1515         break;
1516     }
1517
1518   printf_filtered ("%s", buf);
1519 }
1520
1521
1522 static void
1523 debug_chaos_command (char *args, int from_tty)
1524 {
1525   unsigned char buf[3];
1526
1527   buf[0] = SDI_SET_ATTR;
1528   buf[1] = SDI_ATTR_CACHE;
1529   buf[2] = SDI_CACHE_TYPE_CHAOS;
1530   send_data (buf, 3);
1531 }
1532
1533
1534 static void
1535 use_debug_dma_command (char *args, int from_tty)
1536 {
1537   unsigned char buf[3];
1538
1539   buf[0] = SDI_SET_ATTR;
1540   buf[1] = SDI_ATTR_MEM_ACCESS;
1541   buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1542   send_data (buf, 3);
1543 }
1544
1545 static void
1546 use_mon_code_command (char *args, int from_tty)
1547 {
1548   unsigned char buf[3];
1549
1550   buf[0] = SDI_SET_ATTR;
1551   buf[1] = SDI_ATTR_MEM_ACCESS;
1552   buf[2] = SDI_MEM_ACCESS_MON_CODE;
1553   send_data (buf, 3);
1554 }
1555
1556
1557 static void
1558 use_ib_breakpoints_command (char *args, int from_tty)
1559 {
1560   use_ib_breakpoints = 1;
1561 }
1562
1563 static void
1564 use_dbt_breakpoints_command (char *args, int from_tty)
1565 {
1566   use_ib_breakpoints = 0;
1567 }
1568
1569
1570 /* Define the target subroutine names */
1571
1572 struct target_ops m32r_ops;
1573
1574 static void
1575 init_m32r_ops (void)
1576 {
1577   m32r_ops.to_shortname = "m32rsdi";
1578   m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1579   m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1580   m32r_ops.to_open = m32r_open;
1581   m32r_ops.to_close = m32r_close;
1582   m32r_ops.to_detach = m32r_detach;
1583   m32r_ops.to_resume = m32r_resume;
1584   m32r_ops.to_wait = m32r_wait;
1585   m32r_ops.to_fetch_registers = m32r_fetch_register;
1586   m32r_ops.to_store_registers = m32r_store_register;
1587   m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
1588   m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
1589   m32r_ops.to_files_info = m32r_files_info;
1590   m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1591   m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
1592   m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1593   m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1594   m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1595   m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1596   m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
1597   m32r_ops.to_kill = m32r_kill;
1598   m32r_ops.to_load = m32r_load;
1599   m32r_ops.to_create_inferior = m32r_create_inferior;
1600   m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1601   m32r_ops.to_stop = m32r_stop;
1602   m32r_ops.to_log_command = serial_log_command;
1603   m32r_ops.to_stratum = process_stratum;
1604   m32r_ops.to_has_all_memory = 1;
1605   m32r_ops.to_has_memory = 1;
1606   m32r_ops.to_has_stack = 1;
1607   m32r_ops.to_has_registers = 1;
1608   m32r_ops.to_has_execution = 1;
1609   m32r_ops.to_magic = OPS_MAGIC;
1610 };
1611
1612
1613 extern initialize_file_ftype _initialize_remote_m32r;
1614
1615 void
1616 _initialize_remote_m32r (void)
1617 {
1618   int i;
1619
1620   init_m32r_ops ();
1621
1622   /* Initialize breakpoints. */
1623   for (i = 0; i < MAX_BREAKPOINTS; i++)
1624     bp_address[i] = 0xffffffff;
1625
1626   /* Initialize access breaks. */
1627   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1628     ab_address[i] = 0x00000000;
1629
1630   add_target (&m32r_ops);
1631
1632   add_com ("sdireset", class_obscure, sdireset_command,
1633            _("Reset SDI connection."));
1634
1635   add_com ("sdistatus", class_obscure, sdistatus_command,
1636            _("Show status of SDI connection."));
1637
1638   add_com ("debug_chaos", class_obscure, debug_chaos_command,
1639            _("Debug M32R/Chaos."));
1640
1641   add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1642            _("Use debug DMA mem access."));
1643   add_com ("use_mon_code", class_obscure, use_mon_code_command,
1644            _("Use mon code mem access."));
1645
1646   add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1647            _("Set breakpoints by IB break."));
1648   add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1649            _("Set breakpoints by dbt."));
1650 }