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   write_pc (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 (ptid_t ptid, int step, enum target_signal sig)
 450 {
 451   unsigned long pc_addr, bp_addr, ab_addr;
 452   int ib_breakpoints;
 453   unsigned char buf[13];
 454   int i;
 455
 456   if (remote_debug)
 457     {
 458       if (step)
 459         fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(step)\n");
 460       else
 461         fprintf_unfiltered (gdb_stdlog, "\nm32r_resume(cont)\n");
 462     }
 463
 464   check_mmu_status ();
 465
 466   pc_addr = read_pc ();
 467   if (remote_debug)
 468     fprintf_unfiltered (gdb_stdlog, "pc <= 0x%lx\n", pc_addr);
 469
 470   /* At pc address there is a parallel instruction with +2 offset,
 471      so we have to make it a serial instruction or avoid it. */
 472   if (pc_addr == last_pc_addr)
 473     {
 474       /* Avoid a parallel nop. */
 475       if (last_pc_addr_data[0] == 0xf0 && last_pc_addr_data[1] == 0x00)
 476         {
 477           pc_addr += 2;
 478           /* Now we can forget this instruction. */
 479           last_pc_addr = 0xffffffff;
 480         }
 481       /* Clear a parallel bit. */
 482       else
 483         {
 484           buf[0] = SDI_WRITE_MEMORY;
 485           if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 486             store_long_parameter (buf + 1, pc_addr);
 487           else
 488             store_long_parameter (buf + 1, pc_addr - 1);
 489           store_long_parameter (buf + 5, 1);
 490           buf[9] = last_pc_addr_data[0] & 0x7f;
 491           send_data (buf, 10);
 492         }
 493     }
 494
 495   /* Set PC. */
 496   send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 497
 498   /* step mode. */
 499   step_mode = step;
 500   if (step)
 501     {
 502       /* Set PBP. */
 503       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, pc_addr | 1);
 504     }
 505   else
 506     {
 507       /* Unset PBP. */
 508       send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PBP, 0x00000000);
 509     }
 510
 511   if (use_ib_breakpoints)
 512     ib_breakpoints = max_ib_breakpoints;
 513   else
 514     ib_breakpoints = 0;
 515
 516   /* Set ib breakpoints. */
 517   for (i = 0; i < ib_breakpoints; i++)
 518     {
 519       bp_addr = bp_address[i];
 520
 521       if (bp_addr == 0xffffffff)
 522         continue;
 523
 524       /* Set PBP. */
 525       if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 526         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 527                             0x00000006);
 528       else
 529         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 530                             0x06000000);
 531
 532       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8080 + 4 * i, 4, bp_addr);
 533     }
 534
 535   /* Set dbt breakpoints. */
 536   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 537     {
 538       bp_addr = bp_address[i];
 539
 540       if (bp_addr == 0xffffffff)
 541         continue;
 542
 543       if (!mmu_on)
 544         bp_addr &= 0x7fffffff;
 545
 546       /* Write DBT instruction. */
 547       buf[0] = SDI_WRITE_MEMORY;
 548       store_long_parameter (buf + 1, (bp_addr & 0xfffffffc));
 549       store_long_parameter (buf + 5, 4);
 550       if ((bp_addr & 2) == 0 && bp_addr != (pc_addr & 0xfffffffc))
 551         {
 552           if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 553             {
 554               buf[9] = dbt_bp_entry[0];
 555               buf[10] = dbt_bp_entry[1];
 556               buf[11] = dbt_bp_entry[2];
 557               buf[12] = dbt_bp_entry[3];
 558             }
 559           else
 560             {
 561               buf[9] = dbt_bp_entry[3];
 562               buf[10] = dbt_bp_entry[2];
 563               buf[11] = dbt_bp_entry[1];
 564               buf[12] = dbt_bp_entry[0];
 565             }
 566         }
 567       else
 568         {
 569           if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 570             {
 571               if ((bp_addr & 2) == 0)
 572                 {
 573                   buf[9] = dbt_bp_entry[0];
 574                   buf[10] = dbt_bp_entry[1];
 575                   buf[11] = bp_data[i][2] & 0x7f;
 576                   buf[12] = bp_data[i][3];
 577                 }
 578               else
 579                 {
 580                   buf[9] = bp_data[i][0];
 581                   buf[10] = bp_data[i][1];
 582                   buf[11] = dbt_bp_entry[0];
 583                   buf[12] = dbt_bp_entry[1];
 584                 }
 585             }
 586           else
 587             {
 588               if ((bp_addr & 2) == 0)
 589                 {
 590                   buf[9] = bp_data[i][0];
 591                   buf[10] = bp_data[i][1] & 0x7f;
 592                   buf[11] = dbt_bp_entry[1];
 593                   buf[12] = dbt_bp_entry[0];
 594                 }
 595               else
 596                 {
 597                   buf[9] = dbt_bp_entry[1];
 598                   buf[10] = dbt_bp_entry[0];
 599                   buf[11] = bp_data[i][2];
 600                   buf[12] = bp_data[i][3];
 601                 }
 602             }
 603         }
 604       send_data (buf, 13);
 605     }
 606
 607   /* Set access breaks. */
 608   for (i = 0; i < max_access_breaks; i++)
 609     {
 610       ab_addr = ab_address[i];
 611
 612       if (ab_addr == 0x00000000)
 613         continue;
 614
 615       /* DBC register */
 616       if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 617         {
 618           switch (ab_type[i])
 619             {
 620             case 0:             /* write watch */
 621               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 622                                   0x00000086);
 623               break;
 624             case 1:             /* read watch */
 625               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 626                                   0x00000046);
 627               break;
 628             case 2:             /* access watch */
 629               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 630                                   0x00000006);
 631               break;
 632             }
 633         }
 634       else
 635         {
 636           switch (ab_type[i])
 637             {
 638             case 0:             /* write watch */
 639               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 640                                   0x86000000);
 641               break;
 642             case 1:             /* read watch */
 643               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 644                                   0x46000000);
 645               break;
 646             case 2:             /* access watch */
 647               send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 648                                   0x06000000);
 649               break;
 650             }
 651         }
 652
 653       /* DBAH register */
 654       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8180 + 4 * i, 4, ab_addr);
 655
 656       /* DBAL register */
 657       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8200 + 4 * i, 4,
 658                           0xffffffff);
 659
 660       /* DBD register */
 661       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8280 + 4 * i, 4,
 662                           0x00000000);
 663
 664       /* DBDM register */
 665       send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8300 + 4 * i, 4,
 666                           0x00000000);
 667     }
 668
 669   /* Resume program. */
 670   send_cmd (SDI_EXEC_CPU);
 671
 672   /* Without this, some commands which require an active target (such as kill)
 673      won't work.  This variable serves (at least) double duty as both the pid
 674      of the target process (if it has such), and as a flag indicating that a
 675      target is active.  These functions should be split out into seperate
 676      variables, especially since GDB will someday have a notion of debugging
 677      several processes.  */
 678   inferior_ptid = remote_m32r_ptid;
 679   add_thread_silent (remote_m32r_ptid);
 680
 681   return;
 682 }
 683
 684 /* Wait until the remote machine stops, then return,
 685    storing status in STATUS just as `wait' would.  */
 686
 687 static void
 688 gdb_cntrl_c (int signo)
 689 {
 690   if (remote_debug)
 691     fprintf_unfiltered (gdb_stdlog, "interrupt\n");
 692   interrupted = 1;
 693 }
 694
 695 static ptid_t
 696 m32r_wait (ptid_t ptid, struct target_waitstatus *status)
 697 {
 698   static RETSIGTYPE (*prev_sigint) ();
 699   unsigned long bp_addr, pc_addr;
 700   int ib_breakpoints;
 701   long i;
 702   unsigned char buf[13];
 703   unsigned long val;
 704   int ret, c;
 705
 706   if (remote_debug)
 707     fprintf_unfiltered (gdb_stdlog, "m32r_wait()\n");
 708
 709   status->kind = TARGET_WAITKIND_EXITED;
 710   status->value.sig = 0;
 711
 712   interrupted = 0;
 713   prev_sigint = signal (SIGINT, gdb_cntrl_c);
 714
 715   /* Wait for ready */
 716   buf[0] = SDI_WAIT_FOR_READY;
 717   if (serial_write (sdi_desc, buf, 1) != 0)
 718     error (_("Remote connection closed"));
 719
 720   while (1)
 721     {
 722       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 723       if (c < 0)
 724         error (_("Remote connection closed"));
 725
 726       if (c == '-')             /* error */
 727         {
 728           status->kind = TARGET_WAITKIND_STOPPED;
 729           status->value.sig = TARGET_SIGNAL_HUP;
 730           return inferior_ptid;
 731         }
 732       else if (c == '+')        /* stopped */
 733         break;
 734
 735       if (interrupted)
 736         ret = serial_write (sdi_desc, "!", 1);  /* packet to interrupt */
 737       else
 738         ret = serial_write (sdi_desc, ".", 1);  /* packet to wait */
 739       if (ret != 0)
 740         error (_("Remote connection closed"));
 741     }
 742
 743   status->kind = TARGET_WAITKIND_STOPPED;
 744   if (interrupted)
 745     status->value.sig = TARGET_SIGNAL_INT;
 746   else
 747     status->value.sig = TARGET_SIGNAL_TRAP;
 748
 749   interrupted = 0;
 750   signal (SIGINT, prev_sigint);
 751
 752   check_mmu_status ();
 753
 754   /* Recover parallel bit. */
 755   if (last_pc_addr != 0xffffffff)
 756     {
 757       buf[0] = SDI_WRITE_MEMORY;
 758       if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 759         store_long_parameter (buf + 1, last_pc_addr);
 760       else
 761         store_long_parameter (buf + 1, last_pc_addr - 1);
 762       store_long_parameter (buf + 5, 1);
 763       buf[9] = last_pc_addr_data[0];
 764       send_data (buf, 10);
 765       last_pc_addr = 0xffffffff;
 766     }
 767
 768   if (use_ib_breakpoints)
 769     ib_breakpoints = max_ib_breakpoints;
 770   else
 771     ib_breakpoints = 0;
 772
 773   /* Set back pc by 2 if m32r is stopped with dbt. */
 774   last_pc_addr = 0xffffffff;
 775   send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BPC);
 776   pc_addr = recv_long_data () - 2;
 777   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 778     {
 779       if (pc_addr == bp_address[i])
 780         {
 781           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BPC, pc_addr);
 782
 783           /* If there is a parallel instruction with +2 offset at pc
 784              address, we have to take care of it later. */
 785           if ((pc_addr & 0x2) != 0)
 786             {
 787               if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 788                 {
 789                   if ((bp_data[i][2] & 0x80) != 0)
 790                     {
 791                       last_pc_addr = pc_addr;
 792                       last_pc_addr_data[0] = bp_data[i][2];
 793                       last_pc_addr_data[1] = bp_data[i][3];
 794                     }
 795                 }
 796               else
 797                 {
 798                   if ((bp_data[i][1] & 0x80) != 0)
 799                     {
 800                       last_pc_addr = pc_addr;
 801                       last_pc_addr_data[0] = bp_data[i][1];
 802                       last_pc_addr_data[1] = bp_data[i][0];
 803                     }
 804                 }
 805             }
 806           break;
 807         }
 808     }
 809
 810   /* Remove ib breakpoints. */
 811   for (i = 0; i < ib_breakpoints; i++)
 812     {
 813       if (bp_address[i] != 0xffffffff)
 814         send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8000 + 4 * i, 4,
 815                             0x00000000);
 816     }
 817   /* Remove dbt breakpoints. */
 818   for (i = ib_breakpoints; i < MAX_BREAKPOINTS; i++)
 819     {
 820       bp_addr = bp_address[i];
 821       if (bp_addr != 0xffffffff)
 822         {
 823           if (!mmu_on)
 824             bp_addr &= 0x7fffffff;
 825           buf[0] = SDI_WRITE_MEMORY;
 826           store_long_parameter (buf + 1, bp_addr & 0xfffffffc);
 827           store_long_parameter (buf + 5, 4);
 828           buf[9] = bp_data[i][0];
 829           buf[10] = bp_data[i][1];
 830           buf[11] = bp_data[i][2];
 831           buf[12] = bp_data[i][3];
 832           send_data (buf, 13);
 833         }
 834     }
 835
 836   /* Remove access breaks. */
 837   hit_watchpoint_addr = 0;
 838   for (i = 0; i < max_access_breaks; i++)
 839     {
 840       if (ab_address[i] != 0x00000000)
 841         {
 842           buf[0] = SDI_READ_MEMORY;
 843           store_long_parameter (buf + 1, 0xffff8100 + 4 * i);
 844           store_long_parameter (buf + 5, 4);
 845           serial_write (sdi_desc, buf, 9);
 846           c = serial_readchar (sdi_desc, SDI_TIMEOUT);
 847           if (c != '-' && recv_data (buf, 4) != -1)
 848             {
 849               if (gdbarch_byte_order (target_gdbarch) == BFD_ENDIAN_BIG)
 850                 {
 851                   if ((buf[3] & 0x1) == 0x1)
 852                     hit_watchpoint_addr = ab_address[i];
 853                 }
 854               else
 855                 {
 856                   if ((buf[0] & 0x1) == 0x1)
 857                     hit_watchpoint_addr = ab_address[i];
 858                 }
 859             }
 860
 861           send_three_arg_cmd (SDI_WRITE_MEMORY, 0xffff8100 + 4 * i, 4,
 862                               0x00000000);
 863         }
 864     }
 865
 866   if (remote_debug)
 867     fprintf_unfiltered (gdb_stdlog, "pc => 0x%lx\n", pc_addr);
 868
 869   return inferior_ptid;
 870 }
 871
 872 /* Terminate the open connection to the remote debugger.
 873    Use this when you want to detach and do something else
 874    with your gdb.  */
 875 static void
 876 m32r_detach (struct target_ops *ops, char *args, int from_tty)
 877 {
 878   if (remote_debug)
 879     fprintf_unfiltered (gdb_stdlog, "m32r_detach(%d)\n", from_tty);
 880
 881   m32r_resume (inferior_ptid, 0, 0);
 882
 883   /* calls m32r_close to do the real work */
 884   pop_target ();
 885   if (from_tty)
 886     fprintf_unfiltered (gdb_stdlog, "Ending remote %s debugging\n",
 887                         target_shortname);
 888 }
 889
 890 /* Return the id of register number REGNO. */
 891
 892 static int
 893 get_reg_id (int regno)
 894 {
 895   switch (regno)
 896     {
 897     case 20:
 898       return SDI_REG_BBPC;
 899     case 21:
 900       return SDI_REG_BPC;
 901     case 22:
 902       return SDI_REG_ACCL;
 903     case 23:
 904       return SDI_REG_ACCH;
 905     case 24:
 906       return SDI_REG_EVB;
 907     }
 908
 909   return regno;
 910 }
 911
 912 /* Read the remote registers into the block REGS.  */
 913
 914 static void m32r_fetch_register (struct regcache *, int);
 915
 916 static void
 917 m32r_fetch_registers (struct regcache *regcache)
 918 {
 919   int regno;
 920
 921   for (regno = 0;
 922        regno < gdbarch_num_regs (get_regcache_arch (regcache));
 923        regno++)
 924     m32r_fetch_register (regcache, regno);
 925 }
 926
 927 /* Fetch register REGNO, or all registers if REGNO is -1.
 928    Returns errno value.  */
 929 static void
 930 m32r_fetch_register (struct regcache *regcache, int regno)
 931 {
 932   unsigned long val, val2, regid;
 933
 934   if (regno == -1)
 935     m32r_fetch_registers (regcache);
 936   else
 937     {
 938       char buffer[MAX_REGISTER_SIZE];
 939
 940       regid = get_reg_id (regno);
 941       send_one_arg_cmd (SDI_READ_CPU_REG, regid);
 942       val = recv_long_data ();
 943
 944       if (regid == SDI_REG_PSW)
 945         {
 946           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
 947           val2 = recv_long_data ();
 948           val = ((0x00cf & val2) << 8) | ((0xcf00 & val) >> 8);
 949         }
 950
 951       if (remote_debug)
 952         fprintf_unfiltered (gdb_stdlog, "m32r_fetch_register(%d,0x%08lx)\n",
 953                             regno, val);
 954
 955       /* We got the number the register holds, but gdb expects to see a
 956          value in the target byte ordering.  */
 957       store_unsigned_integer (buffer, 4, val);
 958       regcache_raw_supply (regcache, regno, buffer);
 959     }
 960   return;
 961 }
 962
 963 /* Store the remote registers from the contents of the block REGS.  */
 964
 965 static void m32r_store_register (struct regcache *, int);
 966
 967 static void
 968 m32r_store_registers (struct regcache *regcache)
 969 {
 970   int regno;
 971
 972   for (regno = 0;
 973        regno < gdbarch_num_regs (get_regcache_arch (regcache));
 974        regno++)
 975     m32r_store_register (regcache, regno);
 976
 977   registers_changed ();
 978 }
 979
 980 /* Store register REGNO, or all if REGNO == 0.
 981    Return errno value.  */
 982 static void
 983 m32r_store_register (struct regcache *regcache, int regno)
 984 {
 985   int regid;
 986   ULONGEST regval, tmp;
 987
 988   if (regno == -1)
 989     m32r_store_registers (regcache);
 990   else
 991     {
 992       regcache_cooked_read_unsigned (regcache, regno, &regval);
 993       regid = get_reg_id (regno);
 994
 995       if (regid == SDI_REG_PSW)
 996         {
 997           unsigned long psw, bbpsw;
 998
 999           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_PSW);
1000           psw = recv_long_data ();
1001
1002           send_one_arg_cmd (SDI_READ_CPU_REG, SDI_REG_BBPSW);
1003           bbpsw = recv_long_data ();
1004
1005           tmp = (0x00cf & psw) | ((0x00cf & regval) << 8);
1006           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_PSW, tmp);
1007
1008           tmp = (0x0030 & bbpsw) | ((0xcf00 & regval) >> 8);
1009           send_two_arg_cmd (SDI_WRITE_CPU_REG, SDI_REG_BBPSW, tmp);
1010         }
1011       else
1012         {
1013           send_two_arg_cmd (SDI_WRITE_CPU_REG, regid, regval);
1014         }
1015
1016       if (remote_debug)
1017         fprintf_unfiltered (gdb_stdlog, "m32r_store_register(%d,0x%08lu)\n",
1018                             regno, (unsigned long) regval);
1019     }
1020 }
1021
1022 /* Get ready to modify the registers array.  On machines which store
1023    individual registers, this doesn't need to do anything.  On machines
1024    which store all the registers in one fell swoop, this makes sure
1025    that registers contains all the registers from the program being
1026    debugged.  */
1027
1028 static void
1029 m32r_prepare_to_store (struct regcache *regcache)
1030 {
1031   /* Do nothing, since we can store individual regs */
1032   if (remote_debug)
1033     fprintf_unfiltered (gdb_stdlog, "m32r_prepare_to_store()\n");
1034 }
1035
1036 static void
1037 m32r_files_info (struct target_ops *target)
1038 {
1039   char *file = "nothing";
1040
1041   if (exec_bfd)
1042     {
1043       file = bfd_get_filename (exec_bfd);
1044       printf_filtered ("\tAttached to %s running program %s\n",
1045                        chip_name, file);
1046     }
1047 }
1048
1049 /* Read/Write memory.  */
1050 static int
1051 m32r_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
1052                   int write,
1053                   struct mem_attrib *attrib, struct target_ops *target)
1054 {
1055   unsigned long taddr;
1056   unsigned char buf[0x2000];
1057   int ret, c;
1058
1059   taddr = memaddr;
1060
1061   if (!mmu_on)
1062     {
1063       if ((taddr & 0xa0000000) == 0x80000000)
1064         taddr &= 0x7fffffff;
1065     }
1066
1067   if (remote_debug)
1068     {
1069       if (write)
1070         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,write)\n",
1071                             paddr (memaddr), len);
1072       else
1073         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory(%s,%d,read)\n",
1074                             paddr (memaddr), len);
1075     }
1076
1077   if (write)
1078     {
1079       buf[0] = SDI_WRITE_MEMORY;
1080       store_long_parameter (buf + 1, taddr);
1081       store_long_parameter (buf + 5, len);
1082       if (len < 0x1000)
1083         {
1084           memcpy (buf + 9, myaddr, len);
1085           ret = send_data (buf, len + 9) - 9;
1086         }
1087       else
1088         {
1089           if (serial_write (sdi_desc, buf, 9) != 0)
1090             {
1091               if (remote_debug)
1092                 fprintf_unfiltered (gdb_stdlog,
1093                                     "m32r_xfer_memory() failed\n");
1094               return 0;
1095             }
1096           ret = send_data (myaddr, len);
1097         }
1098     }
1099   else
1100     {
1101       buf[0] = SDI_READ_MEMORY;
1102       store_long_parameter (buf + 1, taddr);
1103       store_long_parameter (buf + 5, len);
1104       if (serial_write (sdi_desc, buf, 9) != 0)
1105         {
1106           if (remote_debug)
1107             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1108           return 0;
1109         }
1110
1111       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1112       if (c < 0 || c == '-')
1113         {
1114           if (remote_debug)
1115             fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() failed\n");
1116           return 0;
1117         }
1118
1119       ret = recv_data (myaddr, len);
1120     }
1121
1122   if (ret <= 0)
1123     {
1124       if (remote_debug)
1125         fprintf_unfiltered (gdb_stdlog, "m32r_xfer_memory() fails\n");
1126       return 0;
1127     }
1128
1129   return ret;
1130 }
1131
1132 static void
1133 m32r_kill (void)
1134 {
1135   if (remote_debug)
1136     fprintf_unfiltered (gdb_stdlog, "m32r_kill()\n");
1137
1138   inferior_ptid = null_ptid;
1139   delete_thread_silent (remote_m32r_ptid);
1140
1141   return;
1142 }
1143
1144 /* Clean up when a program exits.
1145
1146    The program actually lives on in the remote processor's RAM, and may be
1147    run again without a download.  Don't leave it full of breakpoint
1148    instructions.  */
1149
1150 static void
1151 m32r_mourn_inferior (struct target_ops *ops)
1152 {
1153   if (remote_debug)
1154     fprintf_unfiltered (gdb_stdlog, "m32r_mourn_inferior()\n");
1155
1156   remove_breakpoints ();
1157   generic_mourn_inferior ();
1158 }
1159
1160 static int
1161 m32r_insert_breakpoint (struct bp_target_info *bp_tgt)
1162 {
1163   CORE_ADDR addr = bp_tgt->placed_address;
1164   int ib_breakpoints;
1165   unsigned char buf[13];
1166   int i, c;
1167
1168   if (remote_debug)
1169     fprintf_unfiltered (gdb_stdlog, "m32r_insert_breakpoint(%s,...)\n",
1170                         paddr (addr));
1171
1172   if (use_ib_breakpoints)
1173     ib_breakpoints = max_ib_breakpoints;
1174   else
1175     ib_breakpoints = 0;
1176
1177   for (i = 0; i < MAX_BREAKPOINTS; i++)
1178     {
1179       if (bp_address[i] == 0xffffffff)
1180         {
1181           bp_address[i] = addr;
1182           if (i >= ib_breakpoints)
1183             {
1184               buf[0] = SDI_READ_MEMORY;
1185               if (mmu_on)
1186                 store_long_parameter (buf + 1, addr & 0xfffffffc);
1187               else
1188                 store_long_parameter (buf + 1, addr & 0x7ffffffc);
1189               store_long_parameter (buf + 5, 4);
1190               serial_write (sdi_desc, buf, 9);
1191               c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1192               if (c != '-')
1193                 recv_data (bp_data[i], 4);
1194             }
1195           return 0;
1196         }
1197     }
1198
1199   error (_("Too many breakpoints"));
1200   return 1;
1201 }
1202
1203 static int
1204 m32r_remove_breakpoint (struct bp_target_info *bp_tgt)
1205 {
1206   CORE_ADDR addr = bp_tgt->placed_address;
1207   int i;
1208
1209   if (remote_debug)
1210     fprintf_unfiltered (gdb_stdlog, "m32r_remove_breakpoint(%s)\n",
1211                         paddr (addr));
1212
1213   for (i = 0; i < MAX_BREAKPOINTS; i++)
1214     {
1215       if (bp_address[i] == addr)
1216         {
1217           bp_address[i] = 0xffffffff;
1218           break;
1219         }
1220     }
1221
1222   return 0;
1223 }
1224
1225 static void
1226 m32r_load (char *args, int from_tty)
1227 {
1228   struct cleanup *old_chain;
1229   asection *section;
1230   bfd *pbfd;
1231   bfd_vma entry;
1232   char *filename;
1233   int quiet;
1234   int nostart;
1235   struct timeval start_time, end_time;
1236   unsigned long data_count;     /* Number of bytes transferred to memory */
1237   int ret;
1238   static RETSIGTYPE (*prev_sigint) ();
1239
1240   /* for direct tcp connections, we can do a fast binary download */
1241   quiet = 0;
1242   nostart = 0;
1243   filename = NULL;
1244
1245   while (*args != '\000')
1246     {
1247       char *arg;
1248
1249       while (isspace (*args))
1250         args++;
1251
1252       arg = args;
1253
1254       while ((*args != '\000') && !isspace (*args))
1255         args++;
1256
1257       if (*args != '\000')
1258         *args++ = '\000';
1259
1260       if (*arg != '-')
1261         filename = arg;
1262       else if (strncmp (arg, "-quiet", strlen (arg)) == 0)
1263         quiet = 1;
1264       else if (strncmp (arg, "-nostart", strlen (arg)) == 0)
1265         nostart = 1;
1266       else
1267         error (_("Unknown option `%s'"), arg);
1268     }
1269
1270   if (!filename)
1271     filename = get_exec_file (1);
1272
1273   pbfd = bfd_openr (filename, gnutarget);
1274   if (pbfd == NULL)
1275     {
1276       perror_with_name (filename);
1277       return;
1278     }
1279   old_chain = make_cleanup_bfd_close (pbfd);
1280
1281   if (!bfd_check_format (pbfd, bfd_object))
1282     error (_("\"%s\" is not an object file: %s"), filename,
1283            bfd_errmsg (bfd_get_error ()));
1284
1285   gettimeofday (&start_time, NULL);
1286   data_count = 0;
1287
1288   interrupted = 0;
1289   prev_sigint = signal (SIGINT, gdb_cntrl_c);
1290
1291   for (section = pbfd->sections; section; section = section->next)
1292     {
1293       if (bfd_get_section_flags (pbfd, section) & SEC_LOAD)
1294         {
1295           bfd_vma section_address;
1296           bfd_size_type section_size;
1297           file_ptr fptr;
1298           int n;
1299
1300           section_address = bfd_section_lma (pbfd, section);
1301           section_size = bfd_get_section_size (section);
1302
1303           if (!mmu_on)
1304             {
1305               if ((section_address & 0xa0000000) == 0x80000000)
1306                 section_address &= 0x7fffffff;
1307             }
1308
1309           if (!quiet)
1310             printf_filtered ("[Loading section %s at 0x%lx (%d bytes)]\n",
1311                              bfd_get_section_name (pbfd, section),
1312                              (unsigned long) section_address,
1313                              (int) section_size);
1314
1315           fptr = 0;
1316
1317           data_count += section_size;
1318
1319           n = 0;
1320           while (section_size > 0)
1321             {
1322               char unsigned buf[0x1000 + 9];
1323               int count;
1324
1325               count = min (section_size, 0x1000);
1326
1327               buf[0] = SDI_WRITE_MEMORY;
1328               store_long_parameter (buf + 1, section_address);
1329               store_long_parameter (buf + 5, count);
1330
1331               bfd_get_section_contents (pbfd, section, buf + 9, fptr, count);
1332               if (send_data (buf, count + 9) <= 0)
1333                 error (_("Error while downloading %s section."),
1334                        bfd_get_section_name (pbfd, section));
1335
1336               if (!quiet)
1337                 {
1338                   printf_unfiltered (".");
1339                   if (n++ > 60)
1340                     {
1341                       printf_unfiltered ("\n");
1342                       n = 0;
1343                     }
1344                   gdb_flush (gdb_stdout);
1345                 }
1346
1347               section_address += count;
1348               fptr += count;
1349               section_size -= count;
1350
1351               if (interrupted)
1352                 break;
1353             }
1354
1355           if (!quiet && !interrupted)
1356             {
1357               printf_unfiltered ("done.\n");
1358               gdb_flush (gdb_stdout);
1359             }
1360         }
1361
1362       if (interrupted)
1363         {
1364           printf_unfiltered ("Interrupted.\n");
1365           break;
1366         }
1367     }
1368
1369   interrupted = 0;
1370   signal (SIGINT, prev_sigint);
1371
1372   gettimeofday (&end_time, NULL);
1373
1374   /* Make the PC point at the start address */
1375   if (exec_bfd)
1376     write_pc (bfd_get_start_address (exec_bfd));
1377
1378   inferior_ptid = null_ptid;    /* No process now */
1379   delete_thread_silent (remote_m32r_ptid);
1380
1381   /* This is necessary because many things were based on the PC at the time
1382      that we attached to the monitor, which is no longer valid now that we
1383      have loaded new code (and just changed the PC).  Another way to do this
1384      might be to call normal_stop, except that the stack may not be valid,
1385      and things would get horribly confused... */
1386
1387   clear_symtab_users ();
1388
1389   if (!nostart)
1390     {
1391       entry = bfd_get_start_address (pbfd);
1392
1393       if (!quiet)
1394         printf_unfiltered ("[Starting %s at 0x%lx]\n", filename,
1395                            (unsigned long) entry);
1396     }
1397
1398   print_transfer_performance (gdb_stdout, data_count, 0, &start_time,
1399                               &end_time);
1400
1401   do_cleanups (old_chain);
1402 }
1403
1404 static void
1405 m32r_stop (ptid_t ptid)
1406 {
1407   if (remote_debug)
1408     fprintf_unfiltered (gdb_stdlog, "m32r_stop()\n");
1409
1410   send_cmd (SDI_STOP_CPU);
1411
1412   return;
1413 }
1414
1415
1416 /* Tell whether this target can support a hardware breakpoint.  CNT
1417    is the number of hardware breakpoints already installed.  This
1418    implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
1419
1420 int
1421 m32r_can_use_hw_watchpoint (int type, int cnt, int othertype)
1422 {
1423   return sdi_desc != NULL && cnt < max_access_breaks;
1424 }
1425
1426 /* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
1427    for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
1428    watchpoint. */
1429
1430 int
1431 m32r_insert_watchpoint (CORE_ADDR addr, int len, int type)
1432 {
1433   int i;
1434
1435   if (remote_debug)
1436     fprintf_unfiltered (gdb_stdlog, "m32r_insert_watchpoint(%s,%d,%d)\n",
1437                         paddr (addr), len, type);
1438
1439   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1440     {
1441       if (ab_address[i] == 0x00000000)
1442         {
1443           ab_address[i] = addr;
1444           ab_size[i] = len;
1445           ab_type[i] = type;
1446           return 0;
1447         }
1448     }
1449
1450   error (_("Too many watchpoints"));
1451   return 1;
1452 }
1453
1454 int
1455 m32r_remove_watchpoint (CORE_ADDR addr, int len, int type)
1456 {
1457   int i;
1458
1459   if (remote_debug)
1460     fprintf_unfiltered (gdb_stdlog, "m32r_remove_watchpoint(%s,%d,%d)\n",
1461                         paddr (addr), len, type);
1462
1463   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1464     {
1465       if (ab_address[i] == addr)
1466         {
1467           ab_address[i] = 0x00000000;
1468           break;
1469         }
1470     }
1471
1472   return 0;
1473 }
1474
1475 int
1476 m32r_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1477 {
1478   int rc = 0;
1479   if (hit_watchpoint_addr != 0x00000000)
1480     {
1481       *addr_p = hit_watchpoint_addr;
1482       rc = 1;
1483     }
1484   return rc;
1485 }
1486
1487 int
1488 m32r_stopped_by_watchpoint (void)
1489 {
1490   CORE_ADDR addr;
1491   return m32r_stopped_data_address (&current_target, &addr);
1492 }
1493
1494 /* Check to see if a thread is still alive.  */
1495
1496 static int
1497 m32r_thread_alive (ptid_t ptid)
1498 {
1499   if (ptid_equal (ptid, remote_m32r_ptid))
1500     /* The main task is always alive.  */
1501     return 1;
1502
1503   return 0;
1504 }
1505
1506 /* Convert a thread ID to a string.  Returns the string in a static
1507    buffer.  */
1508
1509 static char *
1510 m32r_pid_to_str (ptid_t ptid)
1511 {
1512   static char buf[64];
1513
1514   if (ptid_equal (remote_m32r_ptid, ptid))
1515     {
1516       xsnprintf (buf, sizeof buf, "Thread <main>");
1517       return buf;
1518     }
1519
1520   return normal_pid_to_str (ptid);
1521 }
1522
1523 static void
1524 sdireset_command (char *args, int from_tty)
1525 {
1526   if (remote_debug)
1527     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1528
1529   send_cmd (SDI_OPEN);
1530
1531   inferior_ptid = null_ptid;
1532   delete_thread_silent (remote_m32r_ptid);
1533 }
1534
1535
1536 static void
1537 sdistatus_command (char *args, int from_tty)
1538 {
1539   unsigned char buf[4096];
1540   int i, c;
1541
1542   if (remote_debug)
1543     fprintf_unfiltered (gdb_stdlog, "m32r_sdireset()\n");
1544
1545   if (!sdi_desc)
1546     return;
1547
1548   send_cmd (SDI_STATUS);
1549   for (i = 0; i < 4096; i++)
1550     {
1551       c = serial_readchar (sdi_desc, SDI_TIMEOUT);
1552       if (c < 0)
1553         return;
1554       buf[i] = c;
1555       if (c == 0)
1556         break;
1557     }
1558
1559   printf_filtered ("%s", buf);
1560 }
1561
1562
1563 static void
1564 debug_chaos_command (char *args, int from_tty)
1565 {
1566   unsigned char buf[3];
1567
1568   buf[0] = SDI_SET_ATTR;
1569   buf[1] = SDI_ATTR_CACHE;
1570   buf[2] = SDI_CACHE_TYPE_CHAOS;
1571   send_data (buf, 3);
1572 }
1573
1574
1575 static void
1576 use_debug_dma_command (char *args, int from_tty)
1577 {
1578   unsigned char buf[3];
1579
1580   buf[0] = SDI_SET_ATTR;
1581   buf[1] = SDI_ATTR_MEM_ACCESS;
1582   buf[2] = SDI_MEM_ACCESS_DEBUG_DMA;
1583   send_data (buf, 3);
1584 }
1585
1586 static void
1587 use_mon_code_command (char *args, int from_tty)
1588 {
1589   unsigned char buf[3];
1590
1591   buf[0] = SDI_SET_ATTR;
1592   buf[1] = SDI_ATTR_MEM_ACCESS;
1593   buf[2] = SDI_MEM_ACCESS_MON_CODE;
1594   send_data (buf, 3);
1595 }
1596
1597
1598 static void
1599 use_ib_breakpoints_command (char *args, int from_tty)
1600 {
1601   use_ib_breakpoints = 1;
1602 }
1603
1604 static void
1605 use_dbt_breakpoints_command (char *args, int from_tty)
1606 {
1607   use_ib_breakpoints = 0;
1608 }
1609
1610
1611 /* Define the target subroutine names */
1612
1613 struct target_ops m32r_ops;
1614
1615 static void
1616 init_m32r_ops (void)
1617 {
1618   m32r_ops.to_shortname = "m32rsdi";
1619   m32r_ops.to_longname = "Remote M32R debugging over SDI interface";
1620   m32r_ops.to_doc = "Use an M32R board using SDI debugging protocol.";
1621   m32r_ops.to_open = m32r_open;
1622   m32r_ops.to_close = m32r_close;
1623   m32r_ops.to_detach = m32r_detach;
1624   m32r_ops.to_resume = m32r_resume;
1625   m32r_ops.to_wait = m32r_wait;
1626   m32r_ops.to_fetch_registers = m32r_fetch_register;
1627   m32r_ops.to_store_registers = m32r_store_register;
1628   m32r_ops.to_prepare_to_store = m32r_prepare_to_store;
1629   m32r_ops.deprecated_xfer_memory = m32r_xfer_memory;
1630   m32r_ops.to_files_info = m32r_files_info;
1631   m32r_ops.to_insert_breakpoint = m32r_insert_breakpoint;
1632   m32r_ops.to_remove_breakpoint = m32r_remove_breakpoint;
1633   m32r_ops.to_can_use_hw_breakpoint = m32r_can_use_hw_watchpoint;
1634   m32r_ops.to_insert_watchpoint = m32r_insert_watchpoint;
1635   m32r_ops.to_remove_watchpoint = m32r_remove_watchpoint;
1636   m32r_ops.to_stopped_by_watchpoint = m32r_stopped_by_watchpoint;
1637   m32r_ops.to_stopped_data_address = m32r_stopped_data_address;
1638   m32r_ops.to_kill = m32r_kill;
1639   m32r_ops.to_load = m32r_load;
1640   m32r_ops.to_create_inferior = m32r_create_inferior;
1641   m32r_ops.to_mourn_inferior = m32r_mourn_inferior;
1642   m32r_ops.to_stop = m32r_stop;
1643   m32r_ops.to_log_command = serial_log_command;
1644   m32r_ops.to_thread_alive = m32r_thread_alive;
1645   m32r_ops.to_pid_to_str = m32r_pid_to_str;
1646   m32r_ops.to_stratum = process_stratum;
1647   m32r_ops.to_has_all_memory = 1;
1648   m32r_ops.to_has_memory = 1;
1649   m32r_ops.to_has_stack = 1;
1650   m32r_ops.to_has_registers = 1;
1651   m32r_ops.to_has_execution = 1;
1652   m32r_ops.to_magic = OPS_MAGIC;
1653 };
1654
1655
1656 extern initialize_file_ftype _initialize_remote_m32r;
1657
1658 void
1659 _initialize_remote_m32r (void)
1660 {
1661   int i;
1662
1663   init_m32r_ops ();
1664
1665   /* Initialize breakpoints. */
1666   for (i = 0; i < MAX_BREAKPOINTS; i++)
1667     bp_address[i] = 0xffffffff;
1668
1669   /* Initialize access breaks. */
1670   for (i = 0; i < MAX_ACCESS_BREAKS; i++)
1671     ab_address[i] = 0x00000000;
1672
1673   add_target (&m32r_ops);
1674
1675   add_com ("sdireset", class_obscure, sdireset_command,
1676            _("Reset SDI connection."));
1677
1678   add_com ("sdistatus", class_obscure, sdistatus_command,
1679            _("Show status of SDI connection."));
1680
1681   add_com ("debug_chaos", class_obscure, debug_chaos_command,
1682            _("Debug M32R/Chaos."));
1683
1684   add_com ("use_debug_dma", class_obscure, use_debug_dma_command,
1685            _("Use debug DMA mem access."));
1686   add_com ("use_mon_code", class_obscure, use_mon_code_command,
1687            _("Use mon code mem access."));
1688
1689   add_com ("use_ib_break", class_obscure, use_ib_breakpoints_command,
1690            _("Set breakpoints by IB break."));
1691   add_com ("use_dbt_break", class_obscure, use_dbt_breakpoints_command,
1692            _("Set breakpoints by dbt."));
1693
1694   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
1695      isn't 0.  */
1696   remote_m32r_ptid = ptid_build (42000, 0, 42000);
1697 }