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