gdb/remote-m32r-sdi.c

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