gdb/remote-m32r-sdi.c

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