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-2014 Free Software Foundation, Inc.
   5
   6    Adapted by Michael Snyder of Cygnus Support.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 /* This module defines communication with the Renesas m32r monitor.  */
  24
  25 #include "defs.h"
  26 #include "gdbcore.h"
  27 #include "target.h"
  28 #include "exceptions.h"
  29 #include "monitor.h"
  30 #include "serial.h"
  31 #include "symtab.h"
  32 #include "command.h"
  33 #include "gdbcmd.h"
  34 #include "symfile.h"            /* for generic load */
  35 #include <sys/time.h>
  36 #include <time.h>               /* for time_t */
  37 #include <string.h>
  38 #include "objfiles.h"           /* for ALL_OBJFILES etc.  */
  39 #include "inferior.h"
  40 #include <ctype.h>
  41 #include "regcache.h"
  42 #include "gdb_bfd.h"
  43 #include "cli/cli-utils.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 = gdb_bfd_open (filename, NULL, -1);
 134   if (!abfd)
 135     error (_("Unable to open file %s."), filename);
 136   cleanup = make_cleanup_bfd_unref (abfd);
 137   if (bfd_check_format (abfd, bfd_object) == 0)
 138     error (_("File is not an object file."));
 139   gettimeofday (&start_time, NULL);
 140 #if 0
 141   for (s = abfd->sections; s; s = s->next)
 142     if (s->flags & SEC_LOAD)
 143       {
 144         bfd_size_type section_size = bfd_section_size (abfd, s);
 145         bfd_vma section_base = bfd_section_vma (abfd, s);
 146         unsigned int buffer;
 147
 148         data_count += section_size;
 149
 150         printf_filtered ("Loading section %s, size 0x%lx vma ",
 151                          bfd_section_name (abfd, s), section_size);
 152         fputs_filtered (paddress (target_gdbarch (), section_base), gdb_stdout);
 153         printf_filtered ("\n");
 154         gdb_flush (gdb_stdout);
 155         monitor_printf ("%x mw\r", section_base);
 156         for (i = 0; i < section_size; i += 4)
 157           {
 158             monitor_expect (" -> ", NULL, 0);
 159             bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4);
 160             monitor_printf ("%x\n", buffer);
 161           }
 162         monitor_expect (" -> ", NULL, 0);
 163         monitor_printf ("q\n");
 164         monitor_expect_prompt (NULL, 0);
 165       }
 166 #else
 167   if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL)))
 168     {
 169       monitor_printf ("q\n");
 170       do_cleanups (cleanup);
 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 (struct target_ops *self, const char *filename, int from_tty)
 200 {
 201   generic_load (filename, from_tty);
 202 }
 203
 204 /* This array of registers needs to match the indexes used by GDB.  The
 205    whole reason this exists is because the various ROM monitors use
 206    different names than GDB does, and don't support all the registers
 207    either.  So, typing "info reg sp" becomes an "A7".  */
 208
 209 static char *m32r_regnames[] =
 210   { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 211   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 212   "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch",
 213 };
 214
 215 static void
 216 m32r_supply_register (struct regcache *regcache, char *regname,
 217                       int regnamelen, char *val, int vallen)
 218 {
 219   int regno;
 220   int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]);
 221   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 222
 223   for (regno = 0; regno < num_regs; regno++)
 224     if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0)
 225       break;
 226
 227   if (regno >= num_regs)
 228     return;                     /* no match */
 229
 230   if (regno == ACCL_REGNUM)
 231     {                           /* Special handling for 64-bit acc reg.  */
 232       monitor_supply_register (regcache, ACCH_REGNUM, val);
 233       val = strchr (val, ':');  /* Skip past ':' to get 2nd word.  */
 234       if (val != NULL)
 235         monitor_supply_register (regcache, ACCL_REGNUM, val + 1);
 236     }
 237   else
 238     {
 239       monitor_supply_register (regcache, regno, val);
 240       if (regno == PSW_REGNUM)
 241         {
 242 #if (defined SM_REGNUM || defined BSM_REGNUM || defined IE_REGNUM \
 243      || defined BIE_REGNUM || defined COND_REGNUM  || defined CBR_REGNUM \
 244      || defined BPC_REGNUM || defined BCARRY_REGNUM)
 245           unsigned long psw = strtoul (val, NULL, 16);
 246           char *zero = "00000000", *one = "00000001";
 247 #endif
 248
 249 #ifdef SM_REGNUM
 250           /* Stack mode bit */
 251           monitor_supply_register (regcache, SM_REGNUM,
 252                                    (psw & 0x80) ? one : zero);
 253 #endif
 254 #ifdef BSM_REGNUM
 255           /* Backup stack mode bit */
 256           monitor_supply_register (regcache, BSM_REGNUM,
 257                                    (psw & 0x8000) ? one : zero);
 258 #endif
 259 #ifdef IE_REGNUM
 260           /* Interrupt enable bit */
 261           monitor_supply_register (regcache, IE_REGNUM,
 262                                    (psw & 0x40) ? one : zero);
 263 #endif
 264 #ifdef BIE_REGNUM
 265           /* Backup interrupt enable bit */
 266           monitor_supply_register (regcache, BIE_REGNUM,
 267                                    (psw & 0x4000) ? one : zero);
 268 #endif
 269 #ifdef COND_REGNUM
 270           /* Condition bit (carry etc.) */
 271           monitor_supply_register (regcache, COND_REGNUM,
 272                                    (psw & 0x1) ? one : zero);
 273 #endif
 274 #ifdef CBR_REGNUM
 275           monitor_supply_register (regcache, CBR_REGNUM,
 276                                    (psw & 0x1) ? one : zero);
 277 #endif
 278 #ifdef BPC_REGNUM
 279           monitor_supply_register (regcache, BPC_REGNUM,
 280                                    zero);       /* KLUDGE:   (???????) */
 281 #endif
 282 #ifdef BCARRY_REGNUM
 283           monitor_supply_register (regcache, BCARRY_REGNUM,
 284                                    zero);       /* KLUDGE: (??????) */
 285 #endif
 286         }
 287
 288       if (regno == SPI_REGNUM || regno == SPU_REGNUM)
 289         {       /* special handling for stack pointer (spu or spi).  */
 290           ULONGEST stackmode, psw;
 291           regcache_cooked_read_unsigned (regcache, PSW_REGNUM, &psw);
 292           stackmode = psw & 0x80;
 293
 294           if (regno == SPI_REGNUM && !stackmode)        /* SP == SPI */
 295             monitor_supply_register (regcache,
 296                                      gdbarch_sp_regnum (gdbarch), val);
 297           else if (regno == SPU_REGNUM && stackmode)    /* SP == SPU */
 298             monitor_supply_register (regcache,
 299                                      gdbarch_sp_regnum (gdbarch), val);
 300         }
 301     }
 302 }
 303
 304 /* m32r RevC board monitor */
 305
 306 static struct target_ops m32r_ops;
 307
 308 static char *m32r_inits[] = { "\r", NULL };
 309
 310 static struct monitor_ops m32r_cmds;
 311
 312 static void
 313 init_m32r_cmds (void)
 314 {
 315   m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST;
 316   m32r_cmds.init = m32r_inits;  /* Init strings */
 317   m32r_cmds.cont = "go\r";      /* continue command */
 318   m32r_cmds.step = "step\r";    /* single step */
 319   m32r_cmds.stop = NULL;        /* interrupt command */
 320   m32r_cmds.set_break = "%x +bp\r";     /* set a breakpoint */
 321   m32r_cmds.clr_break = "%x -bp\r";     /* clear a breakpoint */
 322   m32r_cmds.clr_all_break = "bpoff\r";  /* clear all breakpoints */
 323   m32r_cmds.fill = "%x %x %x fill\r";   /* fill (start length val) */
 324   m32r_cmds.setmem.cmdb = "%x 1 %x fill\r";     /* setmem.cmdb (addr, value) */
 325   m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r";    /* setmem.cmdw (addr, value) */
 326   m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r";    /* setmem.cmdl (addr, value) */
 327   m32r_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
 328   m32r_cmds.setmem.resp_delim = NULL;   /* setmem.resp_delim */
 329   m32r_cmds.setmem.term = NULL; /* setmem.term */
 330   m32r_cmds.setmem.term_cmd = NULL;     /* setmem.term_cmd */
 331   m32r_cmds.getmem.cmdb = "%x %x dump\r";       /* getmem.cmdb (addr, len) */
 332   m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */
 333   m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */
 334   m32r_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, len) */
 335   m32r_cmds.getmem.resp_delim = ": ";   /* getmem.resp_delim */
 336   m32r_cmds.getmem.term = NULL; /* getmem.term */
 337   m32r_cmds.getmem.term_cmd = NULL;     /* getmem.term_cmd */
 338   m32r_cmds.setreg.cmd = "%x to %%%s\r";        /* setreg.cmd (name, value) */
 339   m32r_cmds.setreg.resp_delim = NULL;   /* setreg.resp_delim */
 340   m32r_cmds.setreg.term = NULL; /* setreg.term */
 341   m32r_cmds.setreg.term_cmd = NULL;     /* setreg.term_cmd */
 342   m32r_cmds.getreg.cmd = NULL;  /* getreg.cmd (name) */
 343   m32r_cmds.getreg.resp_delim = NULL;   /* getreg.resp_delim */
 344   m32r_cmds.getreg.term = NULL; /* getreg.term */
 345   m32r_cmds.getreg.term_cmd = NULL;     /* getreg.term_cmd */
 346   m32r_cmds.dump_registers = ".reg\r";  /* dump_registers */
 347                                         /* register_pattern */
 348   m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)";
 349   m32r_cmds.supply_register = m32r_supply_register;
 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 (const 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 = 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 (const 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   struct cleanup *cleanup;
 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       myIPaddress = skip_spaces (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 = gdb_bfd_open (args, NULL, -1);
 528   cleanup = make_cleanup_bfd_unref (abfd);
 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   do_cleanups (cleanup);
 570 }
 571
 572 /* Provide a prototype to silence -Wmissing-prototypes.  */
 573 extern initialize_file_ftype _initialize_m32r_rom;
 574
 575 void
 576 _initialize_m32r_rom (void)
 577 {
 578   /* Initialize m32r RevC monitor target.  */
 579   init_m32r_cmds ();
 580   init_monitor_ops (&m32r_ops);
 581
 582   m32r_ops.to_shortname = "m32r";
 583   m32r_ops.to_longname = "m32r monitor";
 584   m32r_ops.to_load = m32r_load_gen;     /* Monitor lacks a download
 585                                            command.  */
 586   m32r_ops.to_doc = "Debug via the m32r monitor.\n\
 587 Specify the serial device it is connected to (e.g. /dev/ttya).";
 588   m32r_ops.to_open = m32r_open;
 589   add_target (&m32r_ops);
 590
 591   /* Initialize mon2000 monitor target */
 592   init_mon2000_cmds ();
 593   init_monitor_ops (&mon2000_ops);
 594
 595   mon2000_ops.to_shortname = "mon2000";
 596   mon2000_ops.to_longname = "Mon2000 monitor";
 597   mon2000_ops.to_load = m32r_load_gen;  /* Monitor lacks a download
 598                                            command.  */
 599   mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\
 600 Specify the serial device it is connected to (e.g. /dev/ttya).";
 601   mon2000_ops.to_open = mon2000_open;
 602   add_target (&mon2000_ops);
 603
 604   add_setshow_string_cmd ("download-path", class_obscure, &download_path, _("\
 605 Set the default path for downloadable SREC files."), _("\
 606 Show the default path for downloadable SREC files."), _("\
 607 Determines the default path for downloadable SREC files."),
 608                           NULL,
 609                           NULL, /* FIXME: i18n: The default path for
 610                                    downloadable SREC files is %s.  */
 611                           &setlist, &showlist);
 612
 613   add_setshow_string_cmd ("board-address", class_obscure, &board_addr, _("\
 614 Set IP address for M32R-EVA target board."), _("\
 615 Show IP address for M32R-EVA target board."), _("\
 616 Determine the IP address for M32R-EVA target board."),
 617                           NULL,
 618                           NULL, /* FIXME: i18n: IP address for
 619                                    M32R-EVA target board is %s.  */
 620                           &setlist, &showlist);
 621
 622   add_setshow_string_cmd ("server-address", class_obscure, &server_addr, _("\
 623 Set IP address for download server (GDB's host computer)."), _("\
 624 Show IP address for download server (GDB's host computer)."), _("\
 625 Determine the IP address for download server (GDB's host computer)."),
 626                           NULL,
 627                           NULL, /* FIXME: i18n: IP address for
 628                                    download server (GDB's host
 629                                    computer) is %s.  */
 630                           &setlist, &showlist);
 631
 632   add_com ("upload", class_obscure, m32r_upload_command, _("\
 633 Upload the srec file via the monitor's Ethernet upload capability."));
 634
 635   add_com ("tload", class_obscure, m32r_load, _("test upload command."));
 636 }