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