gdb/m32r-rom.c

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