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