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