gdb/m32r-rom.c

   1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB,
   2    the GNU debugger.
   3
   4    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2004 Free Software
   5    Foundation, Inc.
   6
   7    Adapted by Michael Snyder of Cygnus Support.
   8
   9    This file is part of GDB.
  10
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 2 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program; if not, write to the Free Software
  23    Foundation, Inc., 59 Temple Place - Suite 330,
  24    Boston, MA 02111-1307, USA.  */
  25
  26 /* This module defines communication with the Renesas m32r monitor */
  27
  28 #include "defs.h"
  29 #include "gdbcore.h"
  30 #include "target.h"
  31 #include "monitor.h"
  32 #include "serial.h"
  33 #include "symtab.h"
  34 #include "command.h"
  35 #include "gdbcmd.h"
  36 #include "symfile.h"            /* for generic load */
  37 #include <time.h>               /* for time_t */
  38 #include "gdb_string.h"
  39 #include "objfiles.h"           /* for ALL_OBJFILES etc. */
  40 #include "inferior.h"           /* for write_pc() */
  41 #include <ctype.h>
  42 #include "regcache.h"
  43
  44 /*
  45  * All this stuff just to get my host computer's IP address!
  46  */
  47 #include <sys/types.h>
  48 #include <netdb.h>              /* for hostent */
  49 #include <netinet/in.h>         /* for struct in_addr */
  50 #if 1
  51 #include <arpa/inet.h>          /* for inet_ntoa */
  52 #endif
  53
  54 static char *board_addr;        /* user-settable IP address for M32R-EVA */
  55 static char *server_addr;       /* user-settable IP address for gdb host */
  56 static char *download_path;     /* user-settable path for SREC files     */
  57
  58
  59 /* REGNUM */
  60 #define PSW_REGNUM      16
  61 #define SPI_REGNUM      18
  62 #define SPU_REGNUM      19
  63 #define ACCL_REGNUM     22
  64 #define ACCH_REGNUM     23
  65
  66
  67 /*
  68  * Function: m32r_load_1 (helper function)
  69  */
  70
  71 static void
  72 m32r_load_section (bfd *abfd, asection *s, void *obj)
  73 {
  74   unsigned int *data_count = obj;
  75   if (s->flags & SEC_LOAD)
  76     {
  77       bfd_size_type section_size = bfd_section_size (abfd, s);
  78       bfd_vma section_base = bfd_section_lma (abfd, s);
  79       unsigned int buffer, i;
  80
  81       *data_count += section_size;
  82
  83       printf_filtered ("Loading section %s, size 0x%lx lma ",
  84                        bfd_section_name (abfd, s), section_size);
  85       print_address_numeric (section_base, 1, gdb_stdout);
  86       printf_filtered ("\n");
  87       gdb_flush (gdb_stdout);
  88       monitor_printf ("%s mw\r", paddr_nz (section_base));
  89       for (i = 0; i < section_size; i += 4)
  90         {
  91           QUIT;
  92           monitor_expect (" -> ", NULL, 0);
  93           bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
  94           monitor_printf ("%x\n", buffer);
  95         }
  96       monitor_expect (" -> ", NULL, 0);
  97       monitor_printf ("q\n");
  98       monitor_expect_prompt (NULL, 0);
  99     }
 100 }
 101
 102 static int
 103 m32r_load_1 (void *dummy)
 104 {
 105   int data_count = 0;
 106
 107   bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count);
 108   return data_count;
 109 }
 110
 111 /*
 112  * Function: m32r_load (an alternate way to load)
 113  */
 114
 115 static void
 116 m32r_load (char *filename, int from_tty)
 117 {
 118   bfd *abfd;
 119   asection *s;
 120   unsigned int i, data_count = 0;
 121   time_t start_time, end_time;  /* for timing of download */
 122
 123   if (filename == NULL || filename[0] == 0)
 124     filename = get_exec_file (1);
 125
 126   abfd = bfd_openr (filename, 0);
 127   if (!abfd)
 128     error ("Unable to open file %s\n", filename);
 129   if (bfd_check_format (abfd, bfd_object) == 0)
 130     error ("File is not an object file\n");
 131   start_time = time (NULL);
 132 #if 0
 133   for (s = abfd->sections; s; s = s->next)
 134     if (s->flags & SEC_LOAD)
 135       {
 136         bfd_size_type section_size = bfd_section_size (abfd, s);
 137         bfd_vma section_base = bfd_section_vma (abfd, s);
 138         unsigned int buffer;
 139
 140         data_count += section_size;
 141
 142         printf_filtered ("Loading section %s, size 0x%lx vma ",
 143                          bfd_section_name (abfd, s), section_size);
 144         print_address_numeric (section_base, 1, gdb_stdout);
 145         printf_filtered ("\n");
 146         gdb_flush (gdb_stdout);
 147         monitor_printf ("%x mw\r", section_base);
 148         for (i = 0; i < section_size; i += 4)
 149           {
 150             monitor_expect (" -> ", NULL, 0);
 151             bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
 152             monitor_printf ("%x\n", buffer);
 153           }
 154         monitor_expect (" -> ", NULL, 0);
 155         monitor_printf ("q\n");
 156         monitor_expect_prompt (NULL, 0);
 157       }
 158 #else
 159   if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
 160     {
 161       monitor_printf ("q\n");
 162       return;
 163     }
 164 #endif
 165   end_time = time (NULL);
 166   printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd));
 167   print_transfer_performance (gdb_stdout, data_count, 0,
 168                               end_time - start_time);
 169
 170   /* Finally, make the PC point at the start address */
 171   if (exec_bfd)
 172     write_pc (bfd_get_start_address (exec_bfd));
 173
 174   inferior_ptid = null_ptid;    /* No process now */
 175
 176   /* This is necessary because many things were based on the PC at the
 177      time that we attached to the monitor, which is no longer valid
 178      now that we have loaded new code (and just changed the PC).
 179      Another way to do this might be to call normal_stop, except that
 180      the stack may not be valid, and things would get horribly
 181      confused... */
 182
 183   clear_symtab_users ();
 184 }
 185
 186 static void
 187 m32r_load_gen (char *filename, int from_tty)
 188 {
 189   generic_load (filename, from_tty);
 190 }
 191
 192 static void m32r_open (char *args, int from_tty);
 193 static void mon2000_open (char *args, int from_tty);
 194
 195 /* This array of registers needs to match the indexes used by GDB. The
 196    whole reason this exists is because the various ROM monitors use
 197    different names than GDB does, and don't support all the registers
 198    either. So, typing "info reg sp" becomes an "A7". */
 199
 200 static char *m32r_regnames[] =
 201   { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 202   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 203   "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
 204 };
 205
 206 static void
 207 m32r_supply_register (char *regname, int regnamelen, char *val, int vallen)
 208 {
 209   int regno;
 210   int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
 211
 212   for (regno = 0; regno < num_regs; regno++)
 213     if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
 214       break;
 215
 216   if (regno >= num_regs)
 217     return;                     /* no match */
 218
 219   if (regno == ACCL_REGNUM)
 220     {                           /* special handling for 64-bit acc reg */
 221       monitor_supply_register (ACCH_REGNUM, val);
 222       val = strchr (val, ':');  /* skip past ':' to get 2nd word */
 223       if (val != NULL)
 224         monitor_supply_register (ACCL_REGNUM, val + 1);
 225     }
 226   else
 227     {
 228       monitor_supply_register (regno, val);
 229       if (regno == PSW_REGNUM)
 230         {
 231           unsigned long psw = strtoul (val, NULL, 16);
 232           char *zero = "00000000", *one = "00000001";
 233
 234 #ifdef SM_REGNUM
 235           /* Stack mode bit */
 236           monitor_supply_register (SM_REGNUM, (psw & 0x80) ? one : zero);
 237 #endif
 238 #ifdef BSM_REGNUM
 239           /* Backup stack mode bit */
 240           monitor_supply_register (BSM_REGNUM, (psw & 0x8000) ? one : zero);
 241 #endif
 242 #ifdef IE_REGNUM
 243           /* Interrupt enable bit */
 244           monitor_supply_register (IE_REGNUM, (psw & 0x40) ? one : zero);
 245 #endif
 246 #ifdef BIE_REGNUM
 247           /* Backup interrupt enable bit */
 248           monitor_supply_register (BIE_REGNUM, (psw & 0x4000) ? one : zero);
 249 #endif
 250 #ifdef COND_REGNUM
 251           /* Condition bit (carry etc.) */
 252           monitor_supply_register (COND_REGNUM, (psw & 0x1) ? one : zero);
 253 #endif
 254 #ifdef CBR_REGNUM
 255           monitor_supply_register (CBR_REGNUM, (psw & 0x1) ? one : zero);
 256 #endif
 257 #ifdef BPC_REGNUM
 258           monitor_supply_register (BPC_REGNUM, zero);   /* KLUDGE:   (???????) */
 259 #endif
 260 #ifdef BCARRY_REGNUM
 261           monitor_supply_register (BCARRY_REGNUM, zero);        /* KLUDGE: (??????) */
 262 #endif
 263         }
 264
 265       if (regno == SPI_REGNUM || regno == SPU_REGNUM)
 266         {                       /* special handling for stack pointer (spu or spi) */
 267           ULONGEST stackmode, psw;
 268           regcache_cooked_read_unsigned (current_regcache, PSW_REGNUM, &psw);
 269           stackmode = psw & 0x80;
 270
 271           if (regno == SPI_REGNUM && !stackmode)        /* SP == SPI */
 272             monitor_supply_register (SP_REGNUM, val);
 273           else if (regno == SPU_REGNUM && stackmode)    /* SP == SPU */
 274             monitor_supply_register (SP_REGNUM, val);
 275         }
 276     }
 277 }
 278
 279 /* m32r RevC board monitor */
 280
 281 static struct target_ops m32r_ops;
 282
 283 static char *m32r_inits[] = { "\r", NULL };
 284
 285 static struct monitor_ops m32r_cmds;
 286
 287 static void
 288 init_m32r_cmds (void)
 289 {
 290   m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
 291   m32r_cmds.init = m32r_inits;  /* Init strings */
 292   m32r_cmds.cont = "go\r";      /* continue command */
 293   m32r_cmds.step = "step\r";    /* single step */
 294   m32r_cmds.stop = NULL;        /* interrupt command */
 295   m32r_cmds.set_break = "%x +bp\r";     /* set a breakpoint */
 296   m32r_cmds.clr_break = "%x -bp\r";     /* clear a breakpoint */
 297   m32r_cmds.clr_all_break = "bpoff\r";  /* clear all breakpoints */
 298   m32r_cmds.fill = "%x %x %x fill\r";   /* fill (start length val) */
 299   m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";     /* setmem.cmdb (addr, value) */
 300   m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";    /* setmem.cmdw (addr, value) */
 301   m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";    /* setmem.cmdl (addr, value) */
 302   m32r_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
 303   m32r_cmds.setmem.resp_delim = NULL;   /* setmem.resp_delim */
 304   m32r_cmds.setmem.term = NULL; /* setmem.term */
 305   m32r_cmds.setmem.term_cmd = NULL;     /* setmem.term_cmd */
 306   m32r_cmds.getmem.cmdb = "%x %x dump\r";       /* getmem.cmdb (addr, len) */
 307   m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */
 308   m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */
 309   m32r_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
 310   m32r_cmds.getmem.resp_delim = ": ";   /* getmem.resp_delim */
 311   m32r_cmds.getmem.term = NULL; /* getmem.term */
 312   m32r_cmds.getmem.term_cmd = NULL;     /* getmem.term_cmd */
 313   m32r_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
 314   m32r_cmds.setreg.resp_delim = NULL;   /* setreg.resp_delim */
 315   m32r_cmds.setreg.term = NULL; /* setreg.term */
 316   m32r_cmds.setreg.term_cmd = NULL;     /* setreg.term_cmd */
 317   m32r_cmds.getreg.cmd = NULL;  /* getreg.cmd (name) */
 318   m32r_cmds.getreg.resp_delim = NULL;   /* getreg.resp_delim */
 319   m32r_cmds.getreg.term = NULL; /* getreg.term */
 320   m32r_cmds.getreg.term_cmd = NULL;     /* getreg.term_cmd */
 321   m32r_cmds.dump_registers = ".reg\r";  /* dump_registers */
 322   m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";   /* register_pattern */
 323   m32r_cmds.supply_register = m32r_supply_register;
 324   m32r_cmds.load_routine = NULL;        /* load_routine (defaults to SRECs) */
 325   m32r_cmds.load = NULL;        /* download command */
 326   m32r_cmds.loadresp = NULL;    /* load response */
 327   m32r_cmds.prompt = "ok ";     /* monitor command prompt */
 328   m32r_cmds.line_term = "\r";   /* end-of-line terminator */
 329   m32r_cmds.cmd_end = NULL;     /* optional command terminator */
 330   m32r_cmds.target = &m32r_ops; /* target operations */
 331   m32r_cmds.stopbits = SERIAL_1_STOPBITS;       /* number of stop bits */
 332   m32r_cmds.regnames = m32r_regnames;   /* registers names */
 333   m32r_cmds.magic = MONITOR_OPS_MAGIC;  /* magic */
 334 }                               /* init_m32r_cmds */
 335
 336 static void
 337 m32r_open (char *args, int from_tty)
 338 {
 339   monitor_open (args, &m32r_cmds, from_tty);
 340 }
 341
 342 /* Mon2000 monitor (MSA2000 board) */
 343
 344 static struct target_ops mon2000_ops;
 345 static struct monitor_ops mon2000_cmds;
 346
 347 static void
 348 init_mon2000_cmds (void)
 349 {
 350   mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
 351   mon2000_cmds.init = m32r_inits;       /* Init strings */
 352   mon2000_cmds.cont = "go\r";   /* continue command */
 353   mon2000_cmds.step = "step\r"; /* single step */
 354   mon2000_cmds.stop = NULL;     /* interrupt command */
 355   mon2000_cmds.set_break = "%x +bp\r";  /* set a breakpoint */
 356   mon2000_cmds.clr_break = "%x -bp\r";  /* clear a breakpoint */
 357   mon2000_cmds.clr_all_break = "bpoff\r";       /* clear all breakpoints */
 358   mon2000_cmds.fill = "%x %x %x fill\r";        /* fill (start length val) */
 359   mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r";  /* setmem.cmdb (addr, value) */
 360   mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */
 361   mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */
 362   mon2000_cmds.setmem.cmdll = NULL;     /* setmem.cmdll (addr, value) */
 363   mon2000_cmds.setmem.resp_delim = NULL;        /* setmem.resp_delim */
 364   mon2000_cmds.setmem.term = NULL;      /* setmem.term */
 365   mon2000_cmds.setmem.term_cmd = NULL;  /* setmem.term_cmd */
 366   mon2000_cmds.getmem.cmdb = "%x %x dump\r";    /* getmem.cmdb (addr, len) */
 367   mon2000_cmds.getmem.cmdw = NULL;      /* getmem.cmdw (addr, len) */
 368   mon2000_cmds.getmem.cmdl = NULL;      /* getmem.cmdl (addr, len) */
 369   mon2000_cmds.getmem.cmdll = NULL;     /* getmem.cmdll (addr, len) */
 370   mon2000_cmds.getmem.resp_delim = ": ";        /* getmem.resp_delim */
 371   mon2000_cmds.getmem.term = NULL;      /* getmem.term */
 372   mon2000_cmds.getmem.term_cmd = NULL;  /* getmem.term_cmd */
 373   mon2000_cmds.setreg.cmd = "%x to %%%s\r";     /* setreg.cmd (name, value) */
 374   mon2000_cmds.setreg.resp_delim = NULL;        /* setreg.resp_delim */
 375   mon2000_cmds.setreg.term = NULL;      /* setreg.term */
 376   mon2000_cmds.setreg.term_cmd = NULL;  /* setreg.term_cmd */
 377   mon2000_cmds.getreg.cmd = NULL;       /* getreg.cmd (name) */
 378   mon2000_cmds.getreg.resp_delim = NULL;        /* getreg.resp_delim */
 379   mon2000_cmds.getreg.term = NULL;      /* getreg.term */
 380   mon2000_cmds.getreg.term_cmd = NULL;  /* getreg.term_cmd */
 381   mon2000_cmds.dump_registers = ".reg\r";       /* dump_registers */
 382   mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";        /* register_pattern */
 383   mon2000_cmds.supply_register = m32r_supply_register;
 384   mon2000_cmds.load_routine = NULL;     /* load_routine (defaults to SRECs) */
 385   mon2000_cmds.load = NULL;     /* download command */
 386   mon2000_cmds.loadresp = NULL; /* load response */
 387   mon2000_cmds.prompt = "Mon2000>";     /* monitor command prompt */
 388   mon2000_cmds.line_term = "\r";        /* end-of-line terminator */
 389   mon2000_cmds.cmd_end = NULL;  /* optional command terminator */
 390   mon2000_cmds.target = &mon2000_ops;   /* target operations */
 391   mon2000_cmds.stopbits = SERIAL_1_STOPBITS;    /* number of stop bits */
 392   mon2000_cmds.regnames = m32r_regnames;        /* registers names */
 393   mon2000_cmds.magic = MONITOR_OPS_MAGIC;       /* magic */
 394 }                               /* init_mon2000_cmds */
 395
 396 static void
 397 mon2000_open (char *args, int from_tty)
 398 {
 399   monitor_open (args, &mon2000_cmds, from_tty);
 400 }
 401
 402 static void
 403 m32r_upload_command (char *args, int from_tty)
 404 {
 405   bfd *abfd;
 406   asection *s;
 407   time_t start_time, end_time;  /* for timing of download */
 408   int resp_len, data_count = 0;
 409   char buf[1024];
 410   struct hostent *hostent;
 411   struct in_addr inet_addr;
 412
 413   /* first check to see if there's an ethernet port! */
 414   monitor_printf ("ust\r");
 415   resp_len = monitor_expect_prompt (buf, sizeof (buf));
 416   if (!strchr (buf, ':'))
 417     error ("No ethernet connection!");
 418
 419   if (board_addr == 0)
 420     {
 421       /* scan second colon in the output from the "ust" command */
 422       char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1;
 423
 424       while (isspace (*myIPaddress))
 425         myIPaddress++;
 426
 427       if (!strncmp (myIPaddress, "0.0.", 4))    /* empty */
 428         error
 429           ("Please use 'set board-address' to set the M32R-EVA board's IP address.");
 430       if (strchr (myIPaddress, '('))
 431         *(strchr (myIPaddress, '(')) = '\0';    /* delete trailing junk */
 432       board_addr = xstrdup (myIPaddress);
 433     }
 434   if (server_addr == 0)
 435     {
 436       buf[0] = 0;
 437       gethostname (buf, sizeof (buf));
 438       if (buf[0] != 0)
 439         {
 440           hostent = gethostbyname (buf);
 441           if (hostent != 0)
 442             {
 443 #if 1
 444               memcpy (&inet_addr.s_addr, hostent->h_addr,
 445                       sizeof (inet_addr.s_addr));
 446               server_addr = (char *) inet_ntoa (inet_addr);
 447 #else
 448               server_addr = (char *) inet_ntoa (hostent->h_addr);
 449 #endif
 450             }
 451         }
 452       if (server_addr == 0)     /* failed? */
 453         error
 454           ("Need to know gdb host computer's IP address (use 'set server-address')");
 455     }
 456
 457   if (args == 0 || args[0] == 0)        /* no args: upload the current file */
 458     args = get_exec_file (1);
 459
 460   if (args[0] != '/' && download_path == 0)
 461     {
 462       if (current_directory)
 463         download_path = xstrdup (current_directory);
 464       else
 465         error
 466           ("Need to know default download path (use 'set download-path')");
 467     }
 468
 469   start_time = time (NULL);
 470   monitor_printf ("uhip %s\r", server_addr);
 471   resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
 472   monitor_printf ("ulip %s\r", board_addr);
 473   resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
 474   if (args[0] != '/')
 475     monitor_printf ("up %s\r", download_path);  /* use default path */
 476   else
 477     monitor_printf ("up\r");    /* rooted filename/path */
 478   resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
 479
 480   if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec"))
 481     monitor_printf ("ul %s\r", args);
 482   else                          /* add ".srec" suffix */
 483     monitor_printf ("ul %s.srec\r", args);
 484   resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */
 485
 486   if (buf[0] == 0 || strstr (buf, "complete") == 0)
 487     error
 488       ("Upload file not found: %s.srec\nCheck IP addresses and download path.",
 489        args);
 490   else
 491     printf_filtered (" -- Ethernet load complete.\n");
 492
 493   end_time = time (NULL);
 494   abfd = bfd_openr (args, 0);
 495   if (abfd != NULL)
 496     {                           /* Download is done -- print section statistics */
 497       if (bfd_check_format (abfd, bfd_object) == 0)
 498         {
 499           printf_filtered ("File is not an object file\n");
 500         }
 501       for (s = abfd->sections; s; s = s->next)
 502         if (s->flags & SEC_LOAD)
 503           {
 504             bfd_size_type section_size = bfd_section_size (abfd, s);
 505             bfd_vma section_base = bfd_section_lma (abfd, s);
 506             unsigned int buffer;
 507
 508             data_count += section_size;
 509
 510             printf_filtered ("Loading section %s, size 0x%lx lma ",
 511                              bfd_section_name (abfd, s), section_size);
 512             print_address_numeric (section_base, 1, gdb_stdout);
 513             printf_filtered ("\n");
 514             gdb_flush (gdb_stdout);
 515           }
 516       /* Finally, make the PC point at the start address */
 517       write_pc (bfd_get_start_address (abfd));
 518       printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd));
 519       print_transfer_performance (gdb_stdout, data_count, 0,
 520                                   end_time - start_time);
 521     }
 522   inferior_ptid = null_ptid;    /* No process now */
 523
 524   /* This is necessary because many things were based on the PC at the
 525      time that we attached to the monitor, which is no longer valid
 526      now that we have loaded new code (and just changed the PC).
 527      Another way to do this might be to call normal_stop, except that
 528      the stack may not be valid, and things would get horribly
 529      confused... */
 530
 531   clear_symtab_users ();
 532 }
 533
 534 void
 535 _initialize_m32r_rom (void)
 536 {
 537   /* Initialize m32r RevC monitor target */
 538   init_m32r_cmds ();
 539   init_monitor_ops (&m32r_ops);
 540
 541   m32r_ops.to_shortname = "m32r";
 542   m32r_ops.to_longname = "m32r monitor";
 543   m32r_ops.to_load = m32r_load_gen;     /* monitor lacks a download command */
 544   m32r_ops.to_doc = "Debug via the m32r monitor.\n\
 545 Specify the serial device it is connected to (e.g. /dev/ttya).";
 546   m32r_ops.to_open = m32r_open;
 547   add_target (&m32r_ops);
 548
 549   /* Initialize mon2000 monitor target */
 550   init_mon2000_cmds ();
 551   init_monitor_ops (&mon2000_ops);
 552
 553   mon2000_ops.to_shortname = "mon2000";
 554   mon2000_ops.to_longname = "Mon2000 monitor";
 555   mon2000_ops.to_load = m32r_load_gen;  /* monitor lacks a download command */
 556   mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
 557 Specify the serial device it is connected to (e.g. /dev/ttya).";
 558   mon2000_ops.to_open = mon2000_open;
 559   add_target (&mon2000_ops);
 560
 561   add_setshow_cmd ("download-path", class_obscure,
 562                    var_string, &download_path, "\
 563 Set the default path for downloadable SREC files.", "\
 564 Show the default path for downloadable SREC files.", "\
 565 Determines the default path for downloadable SREC files.", "\
 566 The default path for downloadable SREC files is %s.",
 567                    NULL, NULL, &setlist, &showlist);
 568
 569   add_setshow_cmd ("board-address", class_obscure,
 570                    var_string, &board_addr, "\
 571 Set IP address for M32R-EVA target board.", "\
 572 Show IP address for M32R-EVA target board.", "\
 573 Determine the IP address for M32R-EVA target board.", "\
 574 IP address for M32R-EVA target board is %s",
 575                    NULL, NULL, &setlist, &showlist);
 576
 577   add_setshow_cmd ("server-address", class_obscure,
 578                    var_string, &server_addr, "\
 579 Set IP address for download server (GDB's host computer).", "\
 580 Show IP address for download server (GDB's host computer).", "\
 581 Determine the IP address for download server (GDB's host computer).", "\
 582 IP address for download server (GDB's host computer) is %s.",
 583                    NULL, NULL, &setlist, &showlist);
 584
 585   add_com ("upload", class_obscure, m32r_upload_command,
 586            "Upload the srec file via the monitor's Ethernet upload capability.");
 587
 588   add_com ("tload", class_obscure, m32r_load, "test upload command.");
 589 }