gdb/remote-m32r-sdi.c

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