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