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