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